home *** CD-ROM | disk | FTP | other *** search
/ Freelog 115 / FreelogNo115-MaiJuin2013.iso / Internet / AvantBrowser / asetup.exe / _data / webkit / resources.pak / Unnamed File 000121.unknown < prev    next >
Text File  |  2013-04-03  |  82KB  |  3,266 lines
  1.  
  2.  
  3.  
  4. WebInspector = {};
  5. WebInspector.UIString = function(s) { return s; };
  6.  
  7.  
  8.  
  9.  
  10. WebInspector.HeapSnapshotArraySlice = function(array, start, end)
  11. {
  12. this._array = array;
  13. this._start = start;
  14. this.length = end - start;
  15. }
  16.  
  17. WebInspector.HeapSnapshotArraySlice.prototype = {
  18. item: function(index)
  19. {
  20. return this._array[this._start + index];
  21. },
  22.  
  23. slice: function(start, end)
  24. {
  25. if (typeof end === "undefined")
  26. end = this.length;
  27. return this._array.subarray(this._start + start, this._start + end);
  28. }
  29. }
  30.  
  31.  
  32. WebInspector.HeapSnapshotEdge = function(snapshot, edges, edgeIndex)
  33. {
  34. this._snapshot = snapshot;
  35. this._edges = edges;
  36. this.edgeIndex = edgeIndex || 0;
  37. }
  38.  
  39. WebInspector.HeapSnapshotEdge.prototype = {
  40. clone: function()
  41. {
  42. return new WebInspector.HeapSnapshotEdge(this._snapshot, this._edges, this.edgeIndex);
  43. },
  44.  
  45. hasStringName: function()
  46. {
  47. if (!this.isShortcut())
  48. return this._hasStringName();
  49. return isNaN(parseInt(this._name(), 10));
  50. },
  51.  
  52. isElement: function()
  53. {
  54. return this._type() === this._snapshot._edgeElementType;
  55. },
  56.  
  57. isHidden: function()
  58. {
  59. return this._type() === this._snapshot._edgeHiddenType;
  60. },
  61.  
  62. isWeak: function()
  63. {
  64. return this._type() === this._snapshot._edgeWeakType;
  65. },
  66.  
  67. isInternal: function()
  68. {
  69. return this._type() === this._snapshot._edgeInternalType;
  70. },
  71.  
  72. isInvisible: function()
  73. {
  74. return this._type() === this._snapshot._edgeInvisibleType;
  75. },
  76.  
  77. isShortcut: function()
  78. {
  79. return this._type() === this._snapshot._edgeShortcutType;
  80. },
  81.  
  82. name: function()
  83. {
  84. if (!this.isShortcut())
  85. return this._name();
  86. var numName = parseInt(this._name(), 10);
  87. return isNaN(numName) ? this._name() : numName;
  88. },
  89.  
  90. node: function()
  91. {
  92. return new WebInspector.HeapSnapshotNode(this._snapshot, this.nodeIndex());
  93. },
  94.  
  95. nodeIndex: function()
  96. {
  97. return this._edges.item(this.edgeIndex + this._snapshot._edgeToNodeOffset);
  98. },
  99.  
  100. rawEdges: function()
  101. {
  102. return this._edges;
  103. },
  104.  
  105. toString: function()
  106. {
  107. var name = this.name();
  108. switch (this.type()) {
  109. case "context": return "->" + name;
  110. case "element": return "[" + name + "]";
  111. case "weak": return "[[" + name + "]]";
  112. case "property":
  113. return name.indexOf(" ") === -1 ? "." + name : "[\"" + name + "\"]";
  114. case "shortcut":
  115. if (typeof name === "string")
  116. return name.indexOf(" ") === -1 ? "." + name : "[\"" + name + "\"]";
  117. else
  118. return "[" + name + "]";
  119. case "internal":
  120. case "hidden":
  121. case "invisible":
  122. return "{" + name + "}";
  123. };
  124. return "?" + name + "?";
  125. },
  126.  
  127. type: function()
  128. {
  129. return this._snapshot._edgeTypes[this._type()];
  130. },
  131.  
  132. _hasStringName: function()
  133. {
  134. return !this.isElement() && !this.isHidden() && !this.isWeak();
  135. },
  136.  
  137. _name: function()
  138. {
  139. return this._hasStringName() ? this._snapshot._strings[this._nameOrIndex()] : this._nameOrIndex();
  140. },
  141.  
  142. _nameOrIndex: function()
  143. {
  144. return this._edges.item(this.edgeIndex + this._snapshot._edgeNameOffset);
  145. },
  146.  
  147. _type: function()
  148. {
  149. return this._edges.item(this.edgeIndex + this._snapshot._edgeTypeOffset);
  150. }
  151. };
  152.  
  153.  
  154. WebInspector.HeapSnapshotEdgeIterator = function(edge)
  155. {
  156. this.edge = edge;
  157. }
  158.  
  159. WebInspector.HeapSnapshotEdgeIterator.prototype = {
  160. first: function()
  161. {
  162. this.edge.edgeIndex = 0;
  163. },
  164.  
  165. hasNext: function()
  166. {
  167. return this.edge.edgeIndex < this.edge._edges.length;
  168. },
  169.  
  170. index: function()
  171. {
  172. return this.edge.edgeIndex;
  173. },
  174.  
  175. setIndex: function(newIndex)
  176. {
  177. this.edge.edgeIndex = newIndex;
  178. },
  179.  
  180. item: function()
  181. {
  182. return this.edge;
  183. },
  184.  
  185. next: function()
  186. {
  187. this.edge.edgeIndex += this.edge._snapshot._edgeFieldsCount;
  188. }
  189. };
  190.  
  191.  
  192. WebInspector.HeapSnapshotRetainerEdge = function(snapshot, retainedNodeIndex, retainerIndex)
  193. {
  194. this._snapshot = snapshot;
  195. this._retainedNodeIndex = retainedNodeIndex;
  196.  
  197. var retainedNodeOrdinal = retainedNodeIndex / snapshot._nodeFieldCount;
  198. this._firstRetainer = snapshot._firstRetainerIndex[retainedNodeOrdinal];
  199. this._retainersCount = snapshot._firstRetainerIndex[retainedNodeOrdinal + 1] - this._firstRetainer;
  200.  
  201. this.setRetainerIndex(retainerIndex);
  202. }
  203.  
  204. WebInspector.HeapSnapshotRetainerEdge.prototype = {
  205. clone: function()
  206. {
  207. return new WebInspector.HeapSnapshotRetainerEdge(this._snapshot, this._retainedNodeIndex, this.retainerIndex());
  208. },
  209.  
  210. hasStringName: function()
  211. {
  212. return this._edge().hasStringName();
  213. },
  214.  
  215. isElement: function()
  216. {
  217. return this._edge().isElement();
  218. },
  219.  
  220. isHidden: function()
  221. {
  222. return this._edge().isHidden();
  223. },
  224.  
  225. isInternal: function()
  226. {
  227. return this._edge().isInternal();
  228. },
  229.  
  230. isInvisible: function()
  231. {
  232. return this._edge().isInvisible();
  233. },
  234.  
  235. isShortcut: function()
  236. {
  237. return this._edge().isShortcut();
  238. },
  239.  
  240. isWeak: function()
  241. {
  242. return this._edge().isWeak();
  243. },
  244.  
  245. name: function()
  246. {
  247. return this._edge().name();
  248. },
  249.  
  250. node: function()
  251. {
  252. return this._node();
  253. },
  254.  
  255. nodeIndex: function()
  256. {
  257. return this._nodeIndex;
  258. },
  259.  
  260. retainerIndex: function()
  261. {
  262. return this._retainerIndex;
  263. },
  264.  
  265. setRetainerIndex: function(newIndex)
  266. {
  267. if (newIndex !== this._retainerIndex) {
  268. this._retainerIndex = newIndex;
  269. this.edgeIndex = newIndex;
  270. }
  271. },
  272.  
  273. set edgeIndex(edgeIndex)
  274. {
  275. var retainerIndex = this._firstRetainer + edgeIndex;
  276. this._globalEdgeIndex = this._snapshot._retainingEdges[retainerIndex];
  277. this._nodeIndex = this._snapshot._retainingNodes[retainerIndex];
  278. delete this._edgeInstance;
  279. delete this._nodeInstance;
  280. },
  281.  
  282. _node: function()
  283. {
  284. if (!this._nodeInstance)
  285. this._nodeInstance = new WebInspector.HeapSnapshotNode(this._snapshot, this._nodeIndex);
  286. return this._nodeInstance;
  287. },
  288.  
  289. _edge: function()
  290. {
  291. if (!this._edgeInstance) {
  292. var edgeIndex = this._globalEdgeIndex - this._node()._edgeIndexesStart();
  293. this._edgeInstance = new WebInspector.HeapSnapshotEdge(this._snapshot, this._node().rawEdges(), edgeIndex);
  294. }
  295. return this._edgeInstance;
  296. },
  297.  
  298. toString: function()
  299. {
  300. return this._edge().toString();
  301. },
  302.  
  303. type: function()
  304. {
  305. return this._edge().type();
  306. }
  307. }
  308.  
  309.  
  310. WebInspector.HeapSnapshotRetainerEdgeIterator = function(retainer)
  311. {
  312. this.retainer = retainer;
  313. }
  314.  
  315. WebInspector.HeapSnapshotRetainerEdgeIterator.prototype = {
  316. first: function()
  317. {
  318. this.retainer.setRetainerIndex(0);
  319. },
  320.  
  321. hasNext: function()
  322. {
  323. return this.retainer.retainerIndex() < this.retainer._retainersCount;
  324. },
  325.  
  326. index: function()
  327. {
  328. return this.retainer.retainerIndex();
  329. },
  330.  
  331. setIndex: function(newIndex)
  332. {
  333. this.retainer.setRetainerIndex(newIndex);
  334. },
  335.  
  336. item: function()
  337. {
  338. return this.retainer;
  339. },
  340.  
  341. next: function()
  342. {
  343. this.retainer.setRetainerIndex(this.retainer.retainerIndex() + 1);
  344. }
  345. };
  346.  
  347.  
  348. WebInspector.HeapSnapshotNode = function(snapshot, nodeIndex)
  349. {
  350. this._snapshot = snapshot;
  351. this._firstNodeIndex = nodeIndex;
  352. this.nodeIndex = nodeIndex;
  353. }
  354.  
  355. WebInspector.HeapSnapshotNode.prototype = {
  356. canBeQueried: function()
  357. {
  358. var flags = this._snapshot._flagsOfNode(this);
  359. return !!(flags & this._snapshot._nodeFlags.canBeQueried);
  360. },
  361.  
  362. isPageObject: function()
  363. {
  364. var flags = this._snapshot._flagsOfNode(this);
  365. return !!(flags & this._snapshot._nodeFlags.pageObject);
  366. },
  367.  
  368. distanceToWindow: function()
  369. {
  370. return this._snapshot._distancesToWindow[this.nodeIndex / this._snapshot._nodeFieldCount];
  371. },
  372.  
  373. className: function()
  374. {
  375. var type = this.type();
  376. switch (type) {
  377. case "hidden":
  378. return WebInspector.UIString("(system)");
  379. case "object":
  380. case "native":
  381. return this.name();
  382. case "code":
  383. return WebInspector.UIString("(compiled code)");
  384. default:
  385. return "(" + type + ")";
  386. }
  387. },
  388.  
  389. classIndex: function()
  390. {
  391. var snapshot = this._snapshot;
  392. var nodes = snapshot._nodes;
  393. var type = nodes[this.nodeIndex + snapshot._nodeTypeOffset];;
  394. if (type === snapshot._nodeObjectType || type === snapshot._nodeNativeType)
  395. return nodes[this.nodeIndex + snapshot._nodeNameOffset];
  396. return -1 - type;
  397. },
  398.  
  399. dominatorIndex: function()
  400. {
  401. var nodeFieldCount = this._snapshot._nodeFieldCount;
  402. return this._snapshot._dominatorsTree[this.nodeIndex / this._snapshot._nodeFieldCount] * nodeFieldCount;
  403. },
  404.  
  405. edges: function()
  406. {
  407. return new WebInspector.HeapSnapshotEdgeIterator(new WebInspector.HeapSnapshotEdge(this._snapshot, this.rawEdges()));
  408. },
  409.  
  410. edgesCount: function()
  411. {
  412. return (this._edgeIndexesEnd() - this._edgeIndexesStart()) / this._snapshot._edgeFieldsCount;
  413. },
  414.  
  415. flags: function()
  416. {
  417. return this._snapshot._flagsOfNode(this);
  418. },
  419.  
  420. id: function()
  421. {
  422. var snapshot = this._snapshot;
  423. return snapshot._nodes[this.nodeIndex + snapshot._nodeIdOffset];
  424. },
  425.  
  426. isHidden: function()
  427. {
  428. return this._type() === this._snapshot._nodeHiddenType;
  429. },
  430.  
  431. isNative: function()
  432. {
  433. return this._type() === this._snapshot._nodeNativeType;
  434. },
  435.  
  436. isSynthetic: function()
  437. {
  438. return this._type() === this._snapshot._nodeSyntheticType;
  439. },
  440.  
  441. isWindow: function()
  442. {
  443. const windowRE = /^Window/;
  444. return windowRE.test(this.name());
  445. },
  446.  
  447. isDetachedDOMTreesRoot: function()
  448. {
  449. return this.name() === "(Detached DOM trees)";
  450. },
  451.  
  452. isDetachedDOMTree: function()
  453. {
  454. const detachedDOMTreeRE = /^Detached DOM tree/;
  455. return detachedDOMTreeRE.test(this.className());
  456. },
  457.  
  458. isRoot: function()
  459. {
  460. return this.nodeIndex === this._snapshot._rootNodeIndex;
  461. },
  462.  
  463. name: function()
  464. {
  465. return this._snapshot._strings[this._name()];
  466. },
  467.  
  468. rawEdges: function()
  469. {
  470. return new WebInspector.HeapSnapshotArraySlice(this._snapshot._containmentEdges, this._edgeIndexesStart(), this._edgeIndexesEnd());
  471. },
  472.  
  473. retainedSize: function()
  474. {
  475. var snapshot = this._snapshot;
  476. return snapshot._nodes[this.nodeIndex + snapshot._nodeRetainedSizeOffset];
  477. },
  478.  
  479. retainers: function()
  480. {
  481. return new WebInspector.HeapSnapshotRetainerEdgeIterator(new WebInspector.HeapSnapshotRetainerEdge(this._snapshot, this.nodeIndex, 0));
  482. },
  483.  
  484. selfSize: function()
  485. {
  486. var snapshot = this._snapshot;
  487. return snapshot._nodes[this.nodeIndex + snapshot._nodeSelfSizeOffset];
  488. },
  489.  
  490. type: function()
  491. {
  492. return this._snapshot._nodeTypes[this._type()];
  493. },
  494.  
  495. _name: function()
  496. {
  497. var snapshot = this._snapshot;
  498. return snapshot._nodes[this.nodeIndex + snapshot._nodeNameOffset];
  499. },
  500.  
  501. _edgeIndexesStart: function()
  502. {
  503. return this._snapshot._firstEdgeIndexes[this._ordinal()];
  504. },
  505.  
  506. _edgeIndexesEnd: function()
  507. {
  508. return this._snapshot._firstEdgeIndexes[this._ordinal() + 1];
  509. },
  510.  
  511. _ordinal: function()
  512. {
  513. return this.nodeIndex / this._snapshot._nodeFieldCount;
  514. },
  515.  
  516. _nextNodeIndex: function()
  517. {
  518. return this.nodeIndex + this._snapshot._nodeFieldCount;
  519. },
  520.  
  521. _type: function()
  522. {
  523. var snapshot = this._snapshot;
  524. return snapshot._nodes[this.nodeIndex + snapshot._nodeTypeOffset];
  525. }
  526. };
  527.  
  528.  
  529. WebInspector.HeapSnapshotNodeIterator = function(node)
  530. {
  531. this.node = node;
  532. this._nodesLength = node._snapshot._nodes.length;
  533. }
  534.  
  535. WebInspector.HeapSnapshotNodeIterator.prototype = {
  536. first: function()
  537. {
  538. this.node.nodeIndex = this.node._firstNodeIndex;
  539. },
  540.  
  541. hasNext: function()
  542. {
  543. return this.node.nodeIndex < this._nodesLength;
  544. },
  545.  
  546. index: function()
  547. {
  548. return this.node.nodeIndex;
  549. },
  550.  
  551. setIndex: function(newIndex)
  552. {
  553. this.node.nodeIndex = newIndex;
  554. },
  555.  
  556. item: function()
  557. {
  558. return this.node;
  559. },
  560.  
  561. next: function()
  562. {
  563. this.node.nodeIndex = this.node._nextNodeIndex();
  564. }
  565. }
  566.  
  567.  
  568. WebInspector.HeapSnapshot = function(profile)
  569. {
  570. this.uid = profile.snapshot.uid;
  571. this._nodes = profile.nodes;
  572. this._containmentEdges = profile.edges;
  573.  
  574. this._metaNode = profile.snapshot.meta;
  575. this._strings = profile.strings;
  576.  
  577. this._snapshotDiffs = {};
  578. this._aggregatesForDiff = null;
  579.  
  580. this._init();
  581. }
  582.  
  583.  
  584. function HeapSnapshotMetainfo()
  585. {
  586.  
  587. this.node_fields = [];
  588. this.node_types = [];
  589. this.edge_fields = [];
  590. this.edge_types = [];
  591.  
  592.  
  593. this.fields = [];
  594. this.types = [];
  595. }
  596.  
  597.  
  598. function HeapSnapshotHeader()
  599. {
  600.  
  601. this.title = "";
  602. this.uid = 0;
  603. this.meta = new HeapSnapshotMetainfo();
  604. this.node_count = 0;
  605. this.edge_count = 0;
  606. }
  607.  
  608. WebInspector.HeapSnapshot.prototype = {
  609. _init: function()
  610. {
  611. var meta = this._metaNode;
  612. this._rootNodeIndex = 0;
  613.  
  614. this._nodeTypeOffset = meta.node_fields.indexOf("type");
  615. this._nodeNameOffset = meta.node_fields.indexOf("name");
  616. this._nodeIdOffset = meta.node_fields.indexOf("id");
  617. this._nodeSelfSizeOffset = meta.node_fields.indexOf("self_size");
  618. this._nodeEdgeCountOffset = meta.node_fields.indexOf("edge_count");
  619. this._nodeFieldCount = meta.node_fields.length;
  620.  
  621. this._nodeTypes = meta.node_types[this._nodeTypeOffset];
  622. this._nodeHiddenType = this._nodeTypes.indexOf("hidden");
  623. this._nodeObjectType = this._nodeTypes.indexOf("object");
  624. this._nodeNativeType = this._nodeTypes.indexOf("native");
  625. this._nodeCodeType = this._nodeTypes.indexOf("code");
  626. this._nodeSyntheticType = this._nodeTypes.indexOf("synthetic");
  627.  
  628. this._edgeFieldsCount = meta.edge_fields.length;
  629. this._edgeTypeOffset = meta.edge_fields.indexOf("type");
  630. this._edgeNameOffset = meta.edge_fields.indexOf("name_or_index");
  631. this._edgeToNodeOffset = meta.edge_fields.indexOf("to_node");
  632.  
  633. this._edgeTypes = meta.edge_types[this._edgeTypeOffset];
  634. this._edgeTypes.push("invisible");
  635. this._edgeElementType = this._edgeTypes.indexOf("element");
  636. this._edgeHiddenType = this._edgeTypes.indexOf("hidden");
  637. this._edgeInternalType = this._edgeTypes.indexOf("internal");
  638. this._edgeShortcutType = this._edgeTypes.indexOf("shortcut");
  639. this._edgeWeakType = this._edgeTypes.indexOf("weak");
  640. this._edgeInvisibleType = this._edgeTypes.indexOf("invisible");
  641.  
  642. this._nodeFlags = { 
  643. canBeQueried: 1,
  644. detachedDOMTreeNode: 2,
  645. pageObject: 4, 
  646.  
  647. visitedMarkerMask: 0x0ffff, 
  648. visitedMarker:     0x10000  
  649. };
  650.  
  651. this.nodeCount = this._nodes.length / this._nodeFieldCount;
  652. this._edgeCount = this._containmentEdges.length / this._edgeFieldsCount;
  653.  
  654. this._buildEdgeIndexes();
  655. this._markInvisibleEdges();
  656. this._buildRetainers();
  657. this._calculateFlags();
  658. this._calculateObjectToWindowDistance();
  659. var result = this._buildPostOrderIndex();
  660.  
  661. this._dominatorsTree = this._buildDominatorTree(result.postOrderIndex2NodeOrdinal, result.nodeOrdinal2PostOrderIndex);
  662. this._calculateRetainedSizes(result.postOrderIndex2NodeOrdinal);
  663. this._buildDominatedNodes();
  664. },
  665.  
  666. _buildEdgeIndexes: function()
  667. {
  668.  
  669. if (this._nodeEdgeCountOffset === -1) {
  670. var nodes = this._nodes;
  671. var nodeCount = this.nodeCount;
  672. var firstEdgeIndexes = this._firstEdgeIndexes = new Uint32Array(nodeCount + 1);
  673. var nodeFieldCount = this._nodeFieldCount;
  674. var nodeEdgesIndexOffset = this._metaNode.node_fields.indexOf("edges_index");
  675. firstEdgeIndexes[nodeCount] = this._containmentEdges.length;
  676. for (var nodeOrdinal = 0; nodeOrdinal < nodeCount; ++nodeOrdinal) {
  677. firstEdgeIndexes[nodeOrdinal] = nodes[nodeOrdinal * nodeFieldCount + nodeEdgesIndexOffset];
  678. }
  679. return;
  680. }
  681.  
  682. var nodes = this._nodes;
  683. var nodeCount = this.nodeCount;
  684. var firstEdgeIndexes = this._firstEdgeIndexes = new Uint32Array(nodeCount + 1);
  685. var nodeFieldCount = this._nodeFieldCount;
  686. var edgeFieldsCount = this._edgeFieldsCount;
  687. var nodeEdgeCountOffset = this._nodeEdgeCountOffset;
  688. firstEdgeIndexes[nodeCount] = this._containmentEdges.length;
  689. for (var nodeOrdinal = 0, edgeIndex = 0; nodeOrdinal < nodeCount; ++nodeOrdinal) {
  690. firstEdgeIndexes[nodeOrdinal] = edgeIndex;
  691. edgeIndex += nodes[nodeOrdinal * nodeFieldCount + nodeEdgeCountOffset] * edgeFieldsCount;
  692. }
  693. },
  694.  
  695. _buildRetainers: function()
  696. {
  697. var retainingNodes = this._retainingNodes = new Uint32Array(this._edgeCount);
  698. var retainingEdges = this._retainingEdges = new Uint32Array(this._edgeCount);
  699.  
  700.  
  701. var firstRetainerIndex = this._firstRetainerIndex = new Uint32Array(this.nodeCount + 1);
  702.  
  703. var containmentEdges = this._containmentEdges;
  704. var edgeFieldsCount = this._edgeFieldsCount;
  705. var nodeFieldCount = this._nodeFieldCount;
  706. var edgeToNodeOffset = this._edgeToNodeOffset;
  707. var nodes = this._nodes;
  708. var firstEdgeIndexes = this._firstEdgeIndexes;
  709. var nodeCount = this.nodeCount;
  710.  
  711. for (var toNodeFieldIndex = edgeToNodeOffset, l = containmentEdges.length; toNodeFieldIndex < l; toNodeFieldIndex += edgeFieldsCount) {
  712. var toNodeIndex = containmentEdges[toNodeFieldIndex];
  713. if (toNodeIndex % nodeFieldCount)
  714. throw new Error("Invalid toNodeIndex " + toNodeIndex);
  715. ++firstRetainerIndex[toNodeIndex / nodeFieldCount];
  716. }
  717. for (var i = 0, firstUnusedRetainerSlot = 0; i < nodeCount; i++) {
  718. var retainersCount = firstRetainerIndex[i];
  719. firstRetainerIndex[i] = firstUnusedRetainerSlot;
  720. retainingNodes[firstUnusedRetainerSlot] = retainersCount;
  721. firstUnusedRetainerSlot += retainersCount;
  722. }
  723. firstRetainerIndex[nodeCount] = retainingNodes.length;
  724.  
  725. var nextNodeFirstEdgeIndex = firstEdgeIndexes[0];
  726. for (var srcNodeOrdinal = 0; srcNodeOrdinal < nodeCount; ++srcNodeOrdinal) {
  727. var firstEdgeIndex = nextNodeFirstEdgeIndex;
  728. nextNodeFirstEdgeIndex = firstEdgeIndexes[srcNodeOrdinal + 1];
  729. var srcNodeIndex = srcNodeOrdinal * nodeFieldCount;
  730. for (var edgeIndex = firstEdgeIndex; edgeIndex < nextNodeFirstEdgeIndex; edgeIndex += edgeFieldsCount) {
  731. var toNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
  732. if (toNodeIndex % nodeFieldCount)
  733. throw new Error("Invalid toNodeIndex " + toNodeIndex);
  734. var firstRetainerSlotIndex = firstRetainerIndex[toNodeIndex / nodeFieldCount];
  735. var nextUnusedRetainerSlotIndex = firstRetainerSlotIndex + (--retainingNodes[firstRetainerSlotIndex]);
  736. retainingNodes[nextUnusedRetainerSlotIndex] = srcNodeIndex;
  737. retainingEdges[nextUnusedRetainerSlotIndex] = edgeIndex;
  738. }
  739. }
  740. },
  741.  
  742. dispose: function()
  743. {
  744. delete this._nodes;
  745. delete this._strings;
  746. delete this._retainingEdges;
  747. delete this._retainingNodes;
  748. delete this._firstRetainerIndex;
  749. if (this._aggregates) {
  750. delete this._aggregates;
  751. delete this._aggregatesSortedFlags;
  752. }
  753. delete this._dominatedNodes;
  754. delete this._firstDominatedNodeIndex;
  755. delete this._flags;
  756. delete this._distancesToWindow;
  757. delete this._dominatorsTree;
  758. },
  759.  
  760. _allNodes: function()
  761. {
  762. return new WebInspector.HeapSnapshotNodeIterator(this.rootNode());
  763. },
  764.  
  765. rootNode: function()
  766. {
  767. return new WebInspector.HeapSnapshotNode(this, this._rootNodeIndex);
  768. },
  769.  
  770. get rootNodeIndex()
  771. {
  772. return this._rootNodeIndex;
  773. },
  774.  
  775. get totalSize()
  776. {
  777. return this.rootNode().retainedSize();
  778. },
  779.  
  780. _getDominatedIndex: function(nodeIndex)
  781. {
  782. if (nodeIndex % this._nodeFieldCount)
  783. throw new Error("Invalid nodeIndex: " + nodeIndex);
  784. return this._firstDominatedNodeIndex[nodeIndex / this._nodeFieldCount];
  785. },
  786.  
  787. _dominatedNodesOfNode: function(node)
  788. {
  789. var dominatedIndexFrom = this._getDominatedIndex(node.nodeIndex);
  790. var dominatedIndexTo = this._getDominatedIndex(node._nextNodeIndex());
  791. return new WebInspector.HeapSnapshotArraySlice(this._dominatedNodes, dominatedIndexFrom, dominatedIndexTo);
  792. },
  793.  
  794. _flagsOfNode: function(node)
  795. {
  796. return this._flags[node.nodeIndex / this._nodeFieldCount];
  797. },
  798.  
  799.  
  800. aggregates: function(sortedIndexes, key, filterString)
  801. {
  802. if (!this._aggregates) {
  803. this._aggregates = {};
  804. this._aggregatesSortedFlags = {};
  805. }
  806.  
  807. var aggregatesByClassName = this._aggregates[key];
  808. if (aggregatesByClassName) {
  809. if (sortedIndexes && !this._aggregatesSortedFlags[key]) {
  810. this._sortAggregateIndexes(aggregatesByClassName);
  811. this._aggregatesSortedFlags[key] = sortedIndexes;
  812. }
  813. return aggregatesByClassName;
  814. }
  815.  
  816. var filter;
  817. if (filterString)
  818. filter = this._parseFilter(filterString);
  819.  
  820. var aggregates = this._buildAggregates(filter);
  821. this._calculateClassesRetainedSize(aggregates.aggregatesByClassIndex, filter);
  822. aggregatesByClassName = aggregates.aggregatesByClassName;
  823.  
  824. if (sortedIndexes)
  825. this._sortAggregateIndexes(aggregatesByClassName);
  826.  
  827. this._aggregatesSortedFlags[key] = sortedIndexes;
  828. this._aggregates[key] = aggregatesByClassName;
  829.  
  830. return aggregatesByClassName;
  831. },
  832.  
  833. aggregatesForDiff: function()
  834. {
  835. if (this._aggregatesForDiff)
  836. return this._aggregatesForDiff;
  837.  
  838. var aggregatesByClassName = this.aggregates(true, "allObjects");
  839. this._aggregatesForDiff  = {};
  840.  
  841. var node = new WebInspector.HeapSnapshotNode(this);
  842. for (var className in aggregatesByClassName) {
  843. var aggregate = aggregatesByClassName[className];
  844. var indexes = aggregate.idxs;
  845. var ids = new Array(indexes.length);
  846. var selfSizes = new Array(indexes.length);
  847. for (var i = 0; i < indexes.length; i++) {
  848. node.nodeIndex = indexes[i];
  849. ids[i] = node.id();
  850. selfSizes[i] = node.selfSize();
  851. }
  852.  
  853. this._aggregatesForDiff[className] = {
  854. indexes: indexes,
  855. ids: ids,
  856. selfSizes: selfSizes
  857. };
  858. }
  859. return this._aggregatesForDiff;
  860. },
  861.  
  862. _calculateObjectToWindowDistance: function()
  863. {
  864. var nodeFieldCount = this._nodeFieldCount;
  865. var distances = new Uint32Array(this.nodeCount);
  866.  
  867.  
  868. var nodesToVisit = new Uint32Array(this.nodeCount);
  869. var nodesToVisitLength = 0;
  870. for (var iter = this.rootNode().edges(); iter.hasNext(); iter.next()) {
  871. var node = iter.edge.node();
  872. if (node.isWindow()) {
  873. nodesToVisit[nodesToVisitLength++] = node.nodeIndex;
  874. distances[node.nodeIndex / nodeFieldCount] = 1;
  875. }
  876. }
  877. this._bfs(nodesToVisit, nodesToVisitLength, distances);
  878.  
  879.  
  880. nodesToVisitLength = 0;
  881. nodesToVisit[nodesToVisitLength++] = this._rootNodeIndex;
  882. distances[this._rootNodeIndex / nodeFieldCount] = 1;
  883. this._bfs(nodesToVisit, nodesToVisitLength, distances);
  884. this._distancesToWindow = distances;
  885. },
  886.  
  887. _bfs: function(nodesToVisit, nodesToVisitLength, distances)
  888. {
  889.  
  890. var edgeFieldsCount = this._edgeFieldsCount;
  891. var nodeFieldCount = this._nodeFieldCount;
  892. var containmentEdges = this._containmentEdges;
  893. var firstEdgeIndexes = this._firstEdgeIndexes;
  894. var edgeToNodeOffset = this._edgeToNodeOffset;
  895. var edgeTypeOffset = this._edgeTypeOffset;
  896. var nodes = this._nodes;
  897. var nodeCount = this.nodeCount;
  898. var containmentEdgesLength = containmentEdges.length;
  899. var edgeWeakType = this._edgeWeakType;
  900. var edgeShortcutType = this._edgeShortcutType;
  901.  
  902. var index = 0;
  903. while (index < nodesToVisitLength) {
  904. var nodeIndex = nodesToVisit[index++]; 
  905. var nodeOrdinal = nodeIndex / nodeFieldCount;
  906. var distance = distances[nodeOrdinal] + 1;
  907. var firstEdgeIndex = firstEdgeIndexes[nodeOrdinal];
  908. var edgesEnd = firstEdgeIndexes[nodeOrdinal + 1];
  909. for (var edgeIndex = firstEdgeIndex; edgeIndex < edgesEnd; edgeIndex += edgeFieldsCount) {
  910. var edgeType = containmentEdges[edgeIndex + edgeTypeOffset];
  911. if (edgeType == edgeWeakType)
  912. continue;
  913. var childNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
  914. var childNodeOrdinal = childNodeIndex / nodeFieldCount;
  915. if (distances[childNodeOrdinal])
  916. continue;
  917. distances[childNodeOrdinal] = distance;
  918. nodesToVisit[nodesToVisitLength++] = childNodeIndex;
  919. }
  920. }
  921. if (nodesToVisitLength > nodeCount)
  922. throw new Error("BFS failed. Nodes to visit (" + nodesToVisitLength + ") is more than nodes count (" + nodeCount + ")");
  923. },
  924.  
  925. _buildAggregates: function(filter)
  926. {
  927. var aggregates = {};
  928. var aggregatesByClassName = {};
  929. var classIndexes = [];
  930. var nodes = this._nodes;
  931. var flags = this._flags;
  932. var nodesLength = nodes.length;
  933. var nodeNativeType = this._nodeNativeType;
  934. var nodeFieldCount = this._nodeFieldCount;
  935. var selfSizeOffset = this._nodeSelfSizeOffset;
  936. var nodeTypeOffset = this._nodeTypeOffset;
  937. var pageObjectFlag = this._nodeFlags.pageObject;
  938. var node = new WebInspector.HeapSnapshotNode(this, this._rootNodeIndex);
  939. var distancesToWindow = this._distancesToWindow;
  940.  
  941. for (var nodeIndex = this._rootNodeIndex; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
  942. var nodeOrdinal = nodeIndex / nodeFieldCount;
  943. if (!(flags[nodeOrdinal] & pageObjectFlag))
  944. continue;
  945. node.nodeIndex = nodeIndex;
  946. if (filter && !filter(node))
  947. continue;
  948. var selfSize = nodes[nodeIndex + selfSizeOffset];
  949. if (!selfSize && nodes[nodeIndex + nodeTypeOffset] !== nodeNativeType)
  950. continue;
  951. var classIndex = node.classIndex();
  952. if (!(classIndex in aggregates)) {
  953. var nodeType = node.type();
  954. var nameMatters = nodeType === "object" || nodeType === "native";
  955. var value = {
  956. count: 1,
  957. distanceToWindow: distancesToWindow[nodeOrdinal],
  958. self: selfSize,
  959. maxRet: 0,
  960. type: nodeType,
  961. name: nameMatters ? node.name() : null,
  962. idxs: [nodeIndex]
  963. };
  964. aggregates[classIndex] = value;
  965. classIndexes.push(classIndex);
  966. aggregatesByClassName[node.className()] = value;
  967. } else {
  968. var clss = aggregates[classIndex];
  969. clss.distanceToWindow = Math.min(clss.distanceToWindow, distancesToWindow[nodeOrdinal]);
  970. ++clss.count;
  971. clss.self += selfSize;
  972. clss.idxs.push(nodeIndex);
  973. }
  974. }
  975.  
  976.  
  977. for (var i = 0, l = classIndexes.length; i < l; ++i) {
  978. var classIndex = classIndexes[i];
  979. aggregates[classIndex].idxs = aggregates[classIndex].idxs.slice();
  980. }
  981. return {aggregatesByClassName: aggregatesByClassName, aggregatesByClassIndex: aggregates};
  982. },
  983.  
  984. _calculateClassesRetainedSize: function(aggregates, filter)
  985. {
  986. var rootNodeIndex = this._rootNodeIndex;
  987. var node = new WebInspector.HeapSnapshotNode(this, rootNodeIndex);
  988. var list = [rootNodeIndex];
  989. var sizes = [-1];
  990. var classes = [];
  991. var seenClassNameIndexes = {};
  992. var nodeFieldCount = this._nodeFieldCount;
  993. var nodeTypeOffset = this._nodeTypeOffset;
  994. var nodeNativeType = this._nodeNativeType;
  995. var dominatedNodes = this._dominatedNodes;
  996. var nodes = this._nodes;
  997. var flags = this._flags;
  998. var pageObjectFlag = this._nodeFlags.pageObject;
  999. var firstDominatedNodeIndex = this._firstDominatedNodeIndex;
  1000.  
  1001. while (list.length) {
  1002. var nodeIndex = list.pop();
  1003. node.nodeIndex = nodeIndex;
  1004. var classIndex = node.classIndex();
  1005. var seen = !!seenClassNameIndexes[classIndex];
  1006. var nodeOrdinal = nodeIndex / nodeFieldCount;
  1007. var dominatedIndexFrom = firstDominatedNodeIndex[nodeOrdinal];
  1008. var dominatedIndexTo = firstDominatedNodeIndex[nodeOrdinal + 1];
  1009.  
  1010. if (!seen &&
  1011. (flags[nodeOrdinal] & pageObjectFlag) &&
  1012. (!filter || filter(node)) &&
  1013. (node.selfSize() || nodes[nodeIndex + nodeTypeOffset] === nodeNativeType)
  1014. ) {
  1015. aggregates[classIndex].maxRet += node.retainedSize();
  1016. if (dominatedIndexFrom !== dominatedIndexTo) {
  1017. seenClassNameIndexes[classIndex] = true;
  1018. sizes.push(list.length);
  1019. classes.push(classIndex);
  1020. }
  1021. }
  1022. for (var i = dominatedIndexFrom; i < dominatedIndexTo; i++)
  1023. list.push(dominatedNodes[i]);
  1024.  
  1025. var l = list.length;
  1026. while (sizes[sizes.length - 1] === l) {
  1027. sizes.pop();
  1028. classIndex = classes.pop();
  1029. seenClassNameIndexes[classIndex] = false;
  1030. }
  1031. }
  1032. },
  1033.  
  1034. _sortAggregateIndexes: function(aggregates)
  1035. {
  1036. var nodeA = new WebInspector.HeapSnapshotNode(this);
  1037. var nodeB = new WebInspector.HeapSnapshotNode(this);
  1038. for (var clss in aggregates)
  1039. aggregates[clss].idxs.sort(
  1040. function(idxA, idxB) {
  1041. nodeA.nodeIndex = idxA;
  1042. nodeB.nodeIndex = idxB;
  1043. return nodeA.id() < nodeB.id() ? -1 : 1;
  1044. });
  1045. },
  1046.  
  1047. _buildPostOrderIndex: function()
  1048. {
  1049. var nodeFieldCount = this._nodeFieldCount;
  1050. var nodes = this._nodes;
  1051. var nodeCount = this.nodeCount;
  1052. var rootNodeOrdinal = this._rootNodeIndex / nodeFieldCount;
  1053.  
  1054. var edgeFieldsCount = this._edgeFieldsCount;
  1055. var edgeTypeOffset = this._edgeTypeOffset;
  1056. var edgeToNodeOffset = this._edgeToNodeOffset;
  1057. var edgeShortcutType = this._edgeShortcutType;
  1058. var firstEdgeIndexes = this._firstEdgeIndexes;
  1059. var containmentEdges = this._containmentEdges;
  1060. var containmentEdgesLength = this._containmentEdges.length;
  1061.  
  1062. var flags = this._flags;
  1063. var flag = this._nodeFlags.pageObject;
  1064.  
  1065. var nodesToVisit = new Uint32Array(nodeCount);
  1066. var postOrderIndex2NodeOrdinal = new Uint32Array(nodeCount);
  1067. var nodeOrdinal2PostOrderIndex = new Uint32Array(nodeCount);
  1068. var painted = new Uint8Array(nodeCount);
  1069. var nodesToVisitLength = 0;
  1070. var postOrderIndex = 0;
  1071. var grey = 1;
  1072. var black = 2;
  1073.  
  1074. nodesToVisit[nodesToVisitLength++] = rootNodeOrdinal;
  1075. painted[rootNodeOrdinal] = grey;
  1076.  
  1077. while (nodesToVisitLength) {
  1078. var nodeOrdinal = nodesToVisit[nodesToVisitLength - 1];
  1079. if (painted[nodeOrdinal] === grey) {
  1080. painted[nodeOrdinal] = black;
  1081. var nodeFlag = flags[nodeOrdinal] & flag;
  1082. var beginEdgeIndex = firstEdgeIndexes[nodeOrdinal];
  1083. var endEdgeIndex = firstEdgeIndexes[nodeOrdinal + 1];
  1084. for (var edgeIndex = beginEdgeIndex; edgeIndex < endEdgeIndex; edgeIndex += edgeFieldsCount) {
  1085. if (nodeOrdinal !== rootNodeOrdinal && containmentEdges[edgeIndex + edgeTypeOffset] === edgeShortcutType)
  1086. continue;
  1087. var childNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
  1088. var childNodeOrdinal = childNodeIndex / nodeFieldCount;
  1089. var childNodeFlag = flags[childNodeOrdinal] & flag;
  1090.  
  1091.  
  1092. if (nodeOrdinal !== rootNodeOrdinal && childNodeFlag && !nodeFlag)
  1093. continue;
  1094. if (!painted[childNodeOrdinal]) {
  1095. painted[childNodeOrdinal] = grey;
  1096. nodesToVisit[nodesToVisitLength++] = childNodeOrdinal;
  1097. }
  1098. }
  1099. } else {
  1100. nodeOrdinal2PostOrderIndex[nodeOrdinal] = postOrderIndex;
  1101. postOrderIndex2NodeOrdinal[postOrderIndex++] = nodeOrdinal;
  1102. --nodesToVisitLength;
  1103. }
  1104. }
  1105.  
  1106. if (postOrderIndex !== nodeCount)
  1107. throw new Error("Postordering failed. " + (nodeCount - postOrderIndex) + " hanging nodes");
  1108.  
  1109. return {postOrderIndex2NodeOrdinal: postOrderIndex2NodeOrdinal, nodeOrdinal2PostOrderIndex: nodeOrdinal2PostOrderIndex};
  1110. },
  1111.  
  1112.  
  1113.  
  1114.  
  1115.  
  1116. _buildDominatorTree: function(postOrderIndex2NodeOrdinal, nodeOrdinal2PostOrderIndex)
  1117. {
  1118. var nodeFieldCount = this._nodeFieldCount;
  1119. var nodes = this._nodes;
  1120. var firstRetainerIndex = this._firstRetainerIndex;
  1121. var retainingNodes = this._retainingNodes;
  1122. var retainingEdges = this._retainingEdges;
  1123. var edgeFieldsCount = this._edgeFieldsCount;
  1124. var edgeTypeOffset = this._edgeTypeOffset;
  1125. var edgeToNodeOffset = this._edgeToNodeOffset;
  1126. var edgeShortcutType = this._edgeShortcutType;
  1127. var firstEdgeIndexes = this._firstEdgeIndexes;
  1128. var containmentEdges = this._containmentEdges;
  1129. var containmentEdgesLength = this._containmentEdges.length;
  1130. var rootNodeIndex = this._rootNodeIndex;
  1131.  
  1132. var flags = this._flags;
  1133. var flag = this._nodeFlags.pageObject;
  1134.  
  1135. var nodesCount = postOrderIndex2NodeOrdinal.length;
  1136. var rootPostOrderedIndex = nodesCount - 1;
  1137. var noEntry = nodesCount;
  1138. var dominators = new Uint32Array(nodesCount);
  1139. for (var i = 0; i < rootPostOrderedIndex; ++i)
  1140. dominators[i] = noEntry;
  1141. dominators[rootPostOrderedIndex] = rootPostOrderedIndex;
  1142.  
  1143.  
  1144.  
  1145. var affected = new Uint8Array(nodesCount);
  1146. var nodeOrdinal;
  1147.  
  1148. { 
  1149. nodeOrdinal = this._rootNodeIndex / nodeFieldCount;
  1150. var beginEdgeToNodeFieldIndex = firstEdgeIndexes[nodeOrdinal] + edgeToNodeOffset;
  1151. var endEdgeToNodeFieldIndex = firstEdgeIndexes[nodeOrdinal + 1];
  1152. for (var toNodeFieldIndex = beginEdgeToNodeFieldIndex;
  1153. toNodeFieldIndex < endEdgeToNodeFieldIndex;
  1154. toNodeFieldIndex += edgeFieldsCount) {
  1155. var childNodeOrdinal = containmentEdges[toNodeFieldIndex] / nodeFieldCount;
  1156. affected[nodeOrdinal2PostOrderIndex[childNodeOrdinal]] = 1;
  1157. }
  1158. }
  1159.  
  1160. var changed = true;
  1161. while (changed) {
  1162. changed = false;
  1163. for (var postOrderIndex = rootPostOrderedIndex - 1; postOrderIndex >= 0; --postOrderIndex) {
  1164. if (affected[postOrderIndex] === 0)
  1165. continue;
  1166. affected[postOrderIndex] = 0;
  1167.  
  1168.  
  1169. if (dominators[postOrderIndex] === rootPostOrderedIndex)
  1170. continue;
  1171. nodeOrdinal = postOrderIndex2NodeOrdinal[postOrderIndex];
  1172. var nodeFlag = !!(flags[nodeOrdinal] & flag);
  1173. var newDominatorIndex = noEntry;
  1174. var beginRetainerIndex = firstRetainerIndex[nodeOrdinal];
  1175. var endRetainerIndex = firstRetainerIndex[nodeOrdinal + 1];
  1176. for (var retainerIndex = beginRetainerIndex; retainerIndex < endRetainerIndex; ++retainerIndex) {
  1177. var retainerEdgeIndex = retainingEdges[retainerIndex];
  1178. var retainerEdgeType = containmentEdges[retainerEdgeIndex + edgeTypeOffset];
  1179. var retainerNodeIndex = retainingNodes[retainerIndex];
  1180. if (retainerNodeIndex !== rootNodeIndex && retainerEdgeType === edgeShortcutType)
  1181. continue;
  1182. var retainerNodeOrdinal = retainerNodeIndex / nodeFieldCount;
  1183. var retainerNodeFlag = !!(flags[retainerNodeOrdinal] & flag);
  1184.  
  1185.  
  1186. if (retainerNodeIndex !== rootNodeIndex && nodeFlag && !retainerNodeFlag)
  1187. continue;
  1188. var retanerPostOrderIndex = nodeOrdinal2PostOrderIndex[retainerNodeOrdinal];
  1189. if (dominators[retanerPostOrderIndex] !== noEntry) {
  1190. if (newDominatorIndex === noEntry)
  1191. newDominatorIndex = retanerPostOrderIndex;
  1192. else {
  1193. while (retanerPostOrderIndex !== newDominatorIndex) {
  1194. while (retanerPostOrderIndex < newDominatorIndex)
  1195. retanerPostOrderIndex = dominators[retanerPostOrderIndex];
  1196. while (newDominatorIndex < retanerPostOrderIndex)
  1197. newDominatorIndex = dominators[newDominatorIndex];
  1198. }
  1199. }
  1200.  
  1201.  
  1202. if (newDominatorIndex === rootPostOrderedIndex)
  1203. break;
  1204. }
  1205. }
  1206. if (newDominatorIndex !== noEntry && dominators[postOrderIndex] !== newDominatorIndex) {
  1207. dominators[postOrderIndex] = newDominatorIndex;
  1208. changed = true;
  1209. nodeOrdinal = postOrderIndex2NodeOrdinal[postOrderIndex];
  1210. beginEdgeToNodeFieldIndex = firstEdgeIndexes[nodeOrdinal] + edgeToNodeOffset;
  1211. endEdgeToNodeFieldIndex = firstEdgeIndexes[nodeOrdinal + 1];
  1212. for (var toNodeFieldIndex = beginEdgeToNodeFieldIndex;
  1213. toNodeFieldIndex < endEdgeToNodeFieldIndex;
  1214. toNodeFieldIndex += edgeFieldsCount) {
  1215. var childNodeOrdinal = containmentEdges[toNodeFieldIndex] / nodeFieldCount;
  1216. affected[nodeOrdinal2PostOrderIndex[childNodeOrdinal]] = 1;
  1217. }
  1218. }
  1219. }
  1220. }
  1221.  
  1222. var dominatorsTree = new Uint32Array(nodesCount);
  1223. for (var postOrderIndex = 0, l = dominators.length; postOrderIndex < l; ++postOrderIndex) {
  1224. nodeOrdinal = postOrderIndex2NodeOrdinal[postOrderIndex];
  1225. dominatorsTree[nodeOrdinal] = postOrderIndex2NodeOrdinal[dominators[postOrderIndex]];
  1226. }
  1227. return dominatorsTree;
  1228. },
  1229.  
  1230. _calculateRetainedSizes: function(postOrderIndex2NodeOrdinal)
  1231. {
  1232. var nodeCount = this.nodeCount;
  1233. var nodes = this._nodes;
  1234. var nodeSelfSizeOffset = this._nodeSelfSizeOffset;
  1235. var nodeFieldCount = this._nodeFieldCount;
  1236. var dominatorsTree = this._dominatorsTree;
  1237.  
  1238. var nodeRetainedSizeOffset = this._nodeRetainedSizeOffset = this._nodeEdgeCountOffset;
  1239. delete this._nodeEdgeCountOffset;
  1240.  
  1241. for (var nodeIndex = 0, l = nodes.length; nodeIndex < l; nodeIndex += nodeFieldCount)
  1242. nodes[nodeIndex + nodeRetainedSizeOffset] = nodes[nodeIndex + nodeSelfSizeOffset];
  1243.  
  1244.  
  1245. for (var postOrderIndex = 0; postOrderIndex < nodeCount - 1; ++postOrderIndex) {
  1246. var nodeOrdinal = postOrderIndex2NodeOrdinal[postOrderIndex];
  1247. var nodeIndex = nodeOrdinal * nodeFieldCount;
  1248. var dominatorIndex = dominatorsTree[nodeOrdinal] * nodeFieldCount;
  1249. nodes[dominatorIndex + nodeRetainedSizeOffset] += nodes[nodeIndex + nodeRetainedSizeOffset];
  1250. }
  1251. },
  1252.  
  1253. _buildDominatedNodes: function()
  1254. {
  1255.  
  1256.  
  1257.  
  1258.  
  1259.  
  1260. var indexArray = this._firstDominatedNodeIndex = new Uint32Array(this.nodeCount + 1);
  1261.  
  1262. var dominatedNodes = this._dominatedNodes = new Uint32Array(this.nodeCount - 1);
  1263.  
  1264.  
  1265.  
  1266. var nodeFieldCount = this._nodeFieldCount;
  1267. var dominatorsTree = this._dominatorsTree;
  1268. for (var nodeOrdinal = 1, l = this.nodeCount; nodeOrdinal < l; ++nodeOrdinal)
  1269. ++indexArray[dominatorsTree[nodeOrdinal]];
  1270.  
  1271.  
  1272. var firstDominatedNodeIndex = 0;
  1273. for (var i = 0, l = this.nodeCount; i < l; ++i) {
  1274. var dominatedCount = dominatedNodes[firstDominatedNodeIndex] = indexArray[i];
  1275. indexArray[i] = firstDominatedNodeIndex;
  1276. firstDominatedNodeIndex += dominatedCount;
  1277. }
  1278. indexArray[this.nodeCount] = dominatedNodes.length;
  1279.  
  1280.  
  1281. for (var nodeOrdinal = 1, l = this.nodeCount; nodeOrdinal < l; ++nodeOrdinal) {
  1282. var dominatorOrdinal = dominatorsTree[nodeOrdinal];
  1283. var dominatedRefIndex = indexArray[dominatorOrdinal];
  1284. dominatedRefIndex += (--dominatedNodes[dominatedRefIndex]);
  1285. dominatedNodes[dominatedRefIndex] = nodeOrdinal * nodeFieldCount;
  1286. }
  1287. },
  1288.  
  1289. _markInvisibleEdges: function()
  1290. {
  1291.  
  1292.  
  1293.  
  1294. for (var iter = this.rootNode().edges(); iter.hasNext(); iter.next()) {
  1295. var edge = iter.edge;
  1296. if (!edge.isShortcut())
  1297. continue;
  1298. var node = edge.node();
  1299. var propNames = {};
  1300. for (var innerIter = node.edges(); innerIter.hasNext(); innerIter.next()) {
  1301. var globalObjEdge = innerIter.edge;
  1302. if (globalObjEdge.isShortcut())
  1303. propNames[globalObjEdge._nameOrIndex()] = true;
  1304. }
  1305. for (innerIter.first(); innerIter.hasNext(); innerIter.next()) {
  1306. var globalObjEdge = innerIter.edge;
  1307. if (!globalObjEdge.isShortcut()
  1308. && globalObjEdge.node().isHidden()
  1309. && globalObjEdge._hasStringName()
  1310. && (globalObjEdge._nameOrIndex() in propNames))
  1311. this._containmentEdges[globalObjEdge._edges._start + globalObjEdge.edgeIndex + this._edgeTypeOffset] = this._edgeInvisibleType;
  1312. }
  1313. }
  1314. },
  1315.  
  1316. _numbersComparator: function(a, b)
  1317. {
  1318. return a < b ? -1 : (a > b ? 1 : 0);
  1319. },
  1320.  
  1321. _markDetachedDOMTreeNodes: function()
  1322. {
  1323. var flag = this._nodeFlags.detachedDOMTreeNode;
  1324. var detachedDOMTreesRoot;
  1325. for (var iter = this.rootNode().edges(); iter.hasNext(); iter.next()) {
  1326. var node = iter.edge.node();
  1327. if (node.isDetachedDOMTreesRoot()) {
  1328. detachedDOMTreesRoot = node;
  1329. break;
  1330. }
  1331. }
  1332.  
  1333. if (!detachedDOMTreesRoot)
  1334. return;
  1335.  
  1336. for (var iter = detachedDOMTreesRoot.edges(); iter.hasNext(); iter.next()) {
  1337. var node = iter.edge.node();
  1338. if (node.isDetachedDOMTree()) {
  1339. for (var edgesIter = node.edges(); edgesIter.hasNext(); edgesIter.next())
  1340. this._flags[edgesIter.edge.node().nodeIndex / this._nodeFieldCount] |= flag;
  1341. }
  1342. }
  1343. },
  1344.  
  1345. _markPageOwnedNodes: function()
  1346. {
  1347. var edgeShortcutType = this._edgeShortcutType;
  1348. var edgeToNodeOffset = this._edgeToNodeOffset;
  1349. var edgeTypeOffset = this._edgeTypeOffset;
  1350. var edgeFieldsCount = this._edgeFieldsCount;
  1351. var edgeWeakType = this._edgeWeakType;
  1352. var firstEdgeIndexes = this._firstEdgeIndexes;
  1353. var containmentEdges = this._containmentEdges;
  1354. var containmentEdgesLength = containmentEdges.length;
  1355. var nodes = this._nodes;
  1356. var nodeFieldCount = this._nodeFieldCount;
  1357. var nodesCount = this.nodeCount;
  1358.  
  1359. var flags = this._flags;
  1360. var flag = this._nodeFlags.pageObject;
  1361. var visitedMarker = this._nodeFlags.visitedMarker;
  1362. var visitedMarkerMask = this._nodeFlags.visitedMarkerMask;
  1363. var markerAndFlag = visitedMarker | flag;
  1364.  
  1365. var nodesToVisit = new Uint32Array(nodesCount);
  1366. var nodesToVisitLength = 0;
  1367.  
  1368. var rootNodeOrdinal = this._rootNodeIndex / nodeFieldCount;
  1369. for (var edgeIndex = firstEdgeIndexes[rootNodeOrdinal], endEdgeIndex = firstEdgeIndexes[rootNodeOrdinal + 1];
  1370. edgeIndex < endEdgeIndex;
  1371. edgeIndex += edgeFieldsCount) {
  1372. if (containmentEdges[edgeIndex + edgeTypeOffset] === edgeShortcutType) {
  1373. var nodeOrdinal = containmentEdges[edgeIndex + edgeToNodeOffset] / nodeFieldCount;
  1374. nodesToVisit[nodesToVisitLength++] = nodeOrdinal;
  1375. flags[nodeOrdinal] |= visitedMarker;
  1376. }
  1377. }
  1378.  
  1379. while (nodesToVisitLength) {
  1380. var nodeOrdinal = nodesToVisit[--nodesToVisitLength];
  1381. flags[nodeOrdinal] |= flag;
  1382. flags[nodeOrdinal] &= visitedMarkerMask;
  1383. var beginEdgeIndex = firstEdgeIndexes[nodeOrdinal];
  1384. var endEdgeIndex = firstEdgeIndexes[nodeOrdinal + 1];
  1385. for (var edgeIndex = beginEdgeIndex; edgeIndex < endEdgeIndex; edgeIndex += edgeFieldsCount) {
  1386. var childNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
  1387. var childNodeOrdinal = childNodeIndex / nodeFieldCount;
  1388. if (flags[childNodeOrdinal] & markerAndFlag)
  1389. continue;
  1390. var type = containmentEdges[edgeIndex + edgeTypeOffset];
  1391. if (type === edgeWeakType)
  1392. continue;
  1393. nodesToVisit[nodesToVisitLength++] = childNodeOrdinal;
  1394. flags[childNodeOrdinal] |= visitedMarker;
  1395. }
  1396. }
  1397. },
  1398.  
  1399. _markQueriableHeapObjects: function()
  1400. {
  1401.  
  1402.  
  1403.  
  1404. var flag = this._nodeFlags.canBeQueried;
  1405. var hiddenEdgeType = this._edgeHiddenType;
  1406. var internalEdgeType = this._edgeInternalType;
  1407. var invisibleEdgeType = this._edgeInvisibleType;
  1408. var weakEdgeType = this._edgeWeakType;
  1409. var edgeToNodeOffset = this._edgeToNodeOffset;
  1410. var edgeTypeOffset = this._edgeTypeOffset;
  1411. var edgeFieldsCount = this._edgeFieldsCount;
  1412. var containmentEdges = this._containmentEdges;
  1413. var nodes = this._nodes;
  1414. var nodeCount = this.nodeCount;
  1415. var nodeFieldCount = this._nodeFieldCount;
  1416. var firstEdgeIndexes = this._firstEdgeIndexes;
  1417.  
  1418. var flags = this._flags;
  1419. var list = [];
  1420.  
  1421. for (var iter = this.rootNode().edges(); iter.hasNext(); iter.next()) {
  1422. if (iter.edge.node().isWindow())
  1423. list.push(iter.edge.node().nodeIndex / nodeFieldCount);
  1424. }
  1425.  
  1426. while (list.length) {
  1427. var nodeOrdinal = list.pop();
  1428. if (flags[nodeOrdinal] & flag)
  1429. continue;
  1430. flags[nodeOrdinal] |= flag;
  1431. var beginEdgeIndex = firstEdgeIndexes[nodeOrdinal];
  1432. var endEdgeIndex = firstEdgeIndexes[nodeOrdinal + 1];
  1433. for (var edgeIndex = beginEdgeIndex; edgeIndex < endEdgeIndex; edgeIndex += edgeFieldsCount) {
  1434. var childNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
  1435. var childNodeOrdinal = childNodeIndex / nodeFieldCount;
  1436. if (flags[childNodeOrdinal] & flag)
  1437. continue;
  1438. var type = containmentEdges[edgeIndex + edgeTypeOffset];
  1439. if (type === hiddenEdgeType || type === invisibleEdgeType || type === internalEdgeType || type === weakEdgeType)
  1440. continue;
  1441. list.push(childNodeOrdinal);
  1442. }
  1443. }
  1444. },
  1445.  
  1446. _calculateFlags: function()
  1447. {
  1448. this._flags = new Uint32Array(this.nodeCount);
  1449. this._markDetachedDOMTreeNodes();
  1450. this._markQueriableHeapObjects();
  1451. this._markPageOwnedNodes();
  1452. },
  1453.  
  1454. calculateSnapshotDiff: function(baseSnapshotId, baseSnapshotAggregates)
  1455. {
  1456. var snapshotDiff = this._snapshotDiffs[baseSnapshotId];
  1457. if (snapshotDiff)
  1458. return snapshotDiff;
  1459. snapshotDiff = {};
  1460.  
  1461. var aggregates = this.aggregates(true, "allObjects");
  1462. for (var className in baseSnapshotAggregates) {
  1463. var baseAggregate = baseSnapshotAggregates[className];
  1464. var diff = this._calculateDiffForClass(baseAggregate, aggregates[className]);
  1465. if (diff)
  1466. snapshotDiff[className] = diff;
  1467. }
  1468. var emptyBaseAggregate = { ids: [], indexes: [], selfSizes: [] };
  1469. for (var className in aggregates) {
  1470. if (className in baseSnapshotAggregates)
  1471. continue;
  1472. snapshotDiff[className] = this._calculateDiffForClass(emptyBaseAggregate, aggregates[className]);
  1473. }
  1474.  
  1475. this._snapshotDiffs[baseSnapshotId] = snapshotDiff;
  1476. return snapshotDiff;
  1477. },
  1478.  
  1479. _calculateDiffForClass: function(baseAggregate, aggregate)
  1480. {
  1481. var baseIds = baseAggregate.ids;
  1482. var baseIndexes = baseAggregate.indexes;
  1483. var baseSelfSizes = baseAggregate.selfSizes;
  1484.  
  1485. var indexes = aggregate ? aggregate.idxs : [];
  1486.  
  1487. var i = 0, l = baseIds.length;
  1488. var j = 0, m = indexes.length;
  1489. var diff = { addedCount: 0,
  1490. removedCount: 0,
  1491. addedSize: 0,
  1492. removedSize: 0,
  1493. deletedIndexes: [],
  1494. addedIndexes: [] };
  1495.  
  1496. var nodeB = new WebInspector.HeapSnapshotNode(this, indexes[j]);
  1497. while (i < l && j < m) {
  1498. var nodeAId = baseIds[i];
  1499. if (nodeAId < nodeB.id()) {
  1500. diff.deletedIndexes.push(baseIndexes[i]);
  1501. diff.removedCount++;
  1502. diff.removedSize += baseSelfSizes[i];
  1503. ++i;
  1504. } else if (nodeAId > nodeB.id()) { 
  1505. diff.addedIndexes.push(indexes[j]);
  1506. diff.addedCount++;
  1507. diff.addedSize += nodeB.selfSize();
  1508. nodeB.nodeIndex = indexes[++j];
  1509. } else { 
  1510. ++i;
  1511. nodeB.nodeIndex = indexes[++j];
  1512. }
  1513. }
  1514. while (i < l) {
  1515. diff.deletedIndexes.push(baseIndexes[i]);
  1516. diff.removedCount++;
  1517. diff.removedSize += baseSelfSizes[i];
  1518. ++i;
  1519. }
  1520. while (j < m) {
  1521. diff.addedIndexes.push(indexes[j]);
  1522. diff.addedCount++;
  1523. diff.addedSize += nodeB.selfSize();
  1524. nodeB.nodeIndex = indexes[++j];
  1525. }
  1526. diff.countDelta = diff.addedCount - diff.removedCount;
  1527. diff.sizeDelta = diff.addedSize - diff.removedSize;
  1528. if (!diff.addedCount && !diff.removedCount)
  1529. return null;
  1530. return diff;
  1531. },
  1532.  
  1533. _nodeForSnapshotObjectId: function(snapshotObjectId)
  1534. {
  1535. for (var it = this._allNodes(); it.hasNext(); it.next()) {
  1536. if (it.node.id() === snapshotObjectId)
  1537. return it.node;
  1538. }
  1539. return null;
  1540. },
  1541.  
  1542. nodeClassName: function(snapshotObjectId)
  1543. {
  1544. var node = this._nodeForSnapshotObjectId(snapshotObjectId);
  1545. if (node)
  1546. return node.className();
  1547. return null;
  1548. },
  1549.  
  1550. dominatorIdsForNode: function(snapshotObjectId)
  1551. {
  1552. var node = this._nodeForSnapshotObjectId(snapshotObjectId);
  1553. if (!node)
  1554. return null;
  1555. var result = [];
  1556. while (!node.isRoot()) {
  1557. result.push(node.id());
  1558. node.nodeIndex = node.dominatorIndex();
  1559. }
  1560. return result;
  1561. },
  1562.  
  1563. _parseFilter: function(filter)
  1564. {
  1565. if (!filter)
  1566. return null;
  1567. var parsedFilter = eval("(function(){return " + filter + "})()");
  1568. return parsedFilter.bind(this);
  1569. },
  1570.  
  1571. createEdgesProvider: function(nodeIndex, filter)
  1572. {
  1573. var node = new WebInspector.HeapSnapshotNode(this, nodeIndex);
  1574. return new WebInspector.HeapSnapshotEdgesProvider(this, this._parseFilter(filter), node.edges());
  1575. },
  1576.  
  1577. createRetainingEdgesProvider: function(nodeIndex, filter)
  1578. {
  1579. var node = new WebInspector.HeapSnapshotNode(this, nodeIndex);
  1580. return new WebInspector.HeapSnapshotEdgesProvider(this, this._parseFilter(filter), node.retainers());
  1581. },
  1582.  
  1583. createAddedNodesProvider: function(baseSnapshotId, className)
  1584. {
  1585. var snapshotDiff = this._snapshotDiffs[baseSnapshotId];
  1586. var diffForClass = snapshotDiff[className];
  1587. return new WebInspector.HeapSnapshotNodesProvider(this, null, diffForClass.addedIndexes);
  1588. },
  1589.  
  1590. createDeletedNodesProvider: function(nodeIndexes)
  1591. {
  1592. return new WebInspector.HeapSnapshotNodesProvider(this, null, nodeIndexes);
  1593. },
  1594.  
  1595. createNodesProviderForClass: function(className, aggregatesKey)
  1596. {
  1597. function filter(node) {
  1598. return node.isPageObject();
  1599. }
  1600. return new WebInspector.HeapSnapshotNodesProvider(this, filter, this.aggregates(false, aggregatesKey)[className].idxs);
  1601. },
  1602.  
  1603. createNodesProviderForDominator: function(nodeIndex)
  1604. {
  1605. var node = new WebInspector.HeapSnapshotNode(this, nodeIndex);
  1606. return new WebInspector.HeapSnapshotNodesProvider(this, null, this._dominatedNodesOfNode(node));
  1607. },
  1608.  
  1609. updateStaticData: function()
  1610. {
  1611. return {nodeCount: this.nodeCount, rootNodeIndex: this._rootNodeIndex, totalSize: this.totalSize, uid: this.uid, nodeFlags: this._nodeFlags};
  1612. }
  1613. };
  1614.  
  1615.  
  1616. WebInspector.HeapSnapshotFilteredOrderedIterator = function(iterator, filter, unfilteredIterationOrder)
  1617. {
  1618. this._filter = filter;
  1619. this._iterator = iterator;
  1620. this._unfilteredIterationOrder = unfilteredIterationOrder;
  1621. this._iterationOrder = null;
  1622. this._position = 0;
  1623. this._currentComparator = null;
  1624. this._sortedPrefixLength = 0;
  1625. }
  1626.  
  1627. WebInspector.HeapSnapshotFilteredOrderedIterator.prototype = {
  1628. _createIterationOrder: function()
  1629. {
  1630. if (this._iterationOrder)
  1631. return;
  1632. if (this._unfilteredIterationOrder && !this._filter) {
  1633. this._iterationOrder = this._unfilteredIterationOrder.slice(0);
  1634. this._unfilteredIterationOrder = null;
  1635. return;
  1636. }
  1637. this._iterationOrder = [];
  1638. var iterator = this._iterator;
  1639. if (!this._unfilteredIterationOrder && !this._filter) {
  1640. for (iterator.first(); iterator.hasNext(); iterator.next())
  1641. this._iterationOrder.push(iterator.index());
  1642. } else if (!this._unfilteredIterationOrder) {
  1643. for (iterator.first(); iterator.hasNext(); iterator.next()) {
  1644. if (this._filter(iterator.item()))
  1645. this._iterationOrder.push(iterator.index());
  1646. }
  1647. } else {
  1648. var order = this._unfilteredIterationOrder.constructor === Array ?
  1649. this._unfilteredIterationOrder : this._unfilteredIterationOrder.slice(0);
  1650. for (var i = 0, l = order.length; i < l; ++i) {
  1651. iterator.setIndex(order[i]);
  1652. if (this._filter(iterator.item()))
  1653. this._iterationOrder.push(iterator.index());
  1654. }
  1655. this._unfilteredIterationOrder = null;
  1656. }
  1657. },
  1658.  
  1659. first: function()
  1660. {
  1661. this._position = 0;
  1662. },
  1663.  
  1664. hasNext: function()
  1665. {
  1666. return this._position < this._iterationOrder.length;
  1667. },
  1668.  
  1669. isEmpty: function()
  1670. {
  1671. if (this._iterationOrder)
  1672. return !this._iterationOrder.length;
  1673. if (this._unfilteredIterationOrder && !this._filter)
  1674. return !this._unfilteredIterationOrder.length;
  1675. var iterator = this._iterator;
  1676. if (!this._unfilteredIterationOrder && !this._filter) {
  1677. iterator.first();
  1678. return !iterator.hasNext();
  1679. } else if (!this._unfilteredIterationOrder) {
  1680. for (iterator.first(); iterator.hasNext(); iterator.next())
  1681. if (this._filter(iterator.item()))
  1682. return false;
  1683. } else {
  1684. var order = this._unfilteredIterationOrder.constructor === Array ?
  1685. this._unfilteredIterationOrder : this._unfilteredIterationOrder.slice(0);
  1686. for (var i = 0, l = order.length; i < l; ++i) {
  1687. iterator.setIndex(order[i]);
  1688. if (this._filter(iterator.item()))
  1689. return false;
  1690. }
  1691. }
  1692. return true;
  1693. },
  1694.  
  1695. item: function()
  1696. {
  1697. this._iterator.setIndex(this._iterationOrder[this._position]);
  1698. return this._iterator.item();
  1699. },
  1700.  
  1701. get length()
  1702. {
  1703. this._createIterationOrder();
  1704. return this._iterationOrder.length;
  1705. },
  1706.  
  1707. next: function()
  1708. {
  1709. ++this._position;
  1710. },
  1711.  
  1712.  
  1713. serializeItemsRange: function(begin, end)
  1714. {
  1715. this._createIterationOrder();
  1716. if (begin > end)
  1717. throw new Error("Start position > end position: " + begin + " > " + end);
  1718. if (end >= this._iterationOrder.length)
  1719. end = this._iterationOrder.length;
  1720. if (this._sortedPrefixLength < end) {
  1721. this.sort(this._currentComparator, this._sortedPrefixLength, this._iterationOrder.length - 1, end - this._sortedPrefixLength);
  1722. this._sortedPrefixLength = end;
  1723. }
  1724.  
  1725. this._position = begin;
  1726. var startPosition = this._position;
  1727. var count = end - begin;
  1728. var result = new Array(count);
  1729. for (var i = 0 ; i < count && this.hasNext(); ++i, this.next())
  1730. result[i] = this.serializeItem(this.item());
  1731. result.length = i;
  1732. result.totalLength = this._iterationOrder.length;
  1733.  
  1734. result.startPosition = startPosition;
  1735. result.endPosition = this._position;
  1736. return result;
  1737. },
  1738.  
  1739. sortAll: function()
  1740. {
  1741. this._createIterationOrder();
  1742. if (this._sortedPrefixLength === this._iterationOrder.length)
  1743. return;
  1744. this.sort(this._currentComparator, this._sortedPrefixLength, this._iterationOrder.length - 1, this._iterationOrder.length);
  1745. this._sortedPrefixLength = this._iterationOrder.length;
  1746. },
  1747.  
  1748. sortAndRewind: function(comparator)
  1749. {
  1750. this._currentComparator = comparator;
  1751. this._sortedPrefixLength = 0;
  1752. this.first();
  1753. }
  1754. }
  1755.  
  1756. WebInspector.HeapSnapshotFilteredOrderedIterator.prototype.createComparator = function(fieldNames)
  1757. {
  1758. return {fieldName1:fieldNames[0], ascending1:fieldNames[1], fieldName2:fieldNames[2], ascending2:fieldNames[3]};
  1759. }
  1760.  
  1761.  
  1762. WebInspector.HeapSnapshotEdgesProvider = function(snapshot, filter, edgesIter)
  1763. {
  1764. this.snapshot = snapshot;
  1765. WebInspector.HeapSnapshotFilteredOrderedIterator.call(this, edgesIter, filter);
  1766. }
  1767.  
  1768. WebInspector.HeapSnapshotEdgesProvider.prototype = {
  1769. serializeItem: function(edge)
  1770. {
  1771. return {
  1772. name: edge.name(),
  1773. propertyAccessor: edge.toString(),
  1774. node: WebInspector.HeapSnapshotNodesProvider.prototype.serializeItem(edge.node()),
  1775. nodeIndex: edge.nodeIndex(),
  1776. type: edge.type(),
  1777. distanceToWindow: edge.node().distanceToWindow()
  1778. };
  1779. },
  1780.  
  1781. sort: function(comparator, leftBound, rightBound, count)
  1782. {
  1783. var fieldName1 = comparator.fieldName1;
  1784. var fieldName2 = comparator.fieldName2;
  1785. var ascending1 = comparator.ascending1;
  1786. var ascending2 = comparator.ascending2;
  1787.  
  1788. var edgeA = this._iterator.item().clone();
  1789. var edgeB = edgeA.clone();
  1790. var nodeA = new WebInspector.HeapSnapshotNode(this.snapshot);
  1791. var nodeB = new WebInspector.HeapSnapshotNode(this.snapshot);
  1792.  
  1793. function compareEdgeFieldName(ascending, indexA, indexB)
  1794. {
  1795. edgeA.edgeIndex = indexA;
  1796. edgeB.edgeIndex = indexB;
  1797. if (edgeB.name() === "__proto__") return -1;
  1798. if (edgeA.name() === "__proto__") return 1;
  1799. var result =
  1800. edgeA.hasStringName() === edgeB.hasStringName() ?
  1801. (edgeA.name() < edgeB.name() ? -1 : (edgeA.name() > edgeB.name() ? 1 : 0)) :
  1802. (edgeA.hasStringName() ? -1 : 1);
  1803. return ascending ? result : -result;
  1804. }
  1805.  
  1806. function compareNodeField(fieldName, ascending, indexA, indexB)
  1807. {
  1808. edgeA.edgeIndex = indexA;
  1809. nodeA.nodeIndex = edgeA.nodeIndex();
  1810. var valueA = nodeA[fieldName]();
  1811.  
  1812. edgeB.edgeIndex = indexB;
  1813. nodeB.nodeIndex = edgeB.nodeIndex();
  1814. var valueB = nodeB[fieldName]();
  1815.  
  1816. var result = valueA < valueB ? -1 : (valueA > valueB ? 1 : 0);
  1817. return ascending ? result : -result;
  1818. }
  1819.  
  1820. function compareEdgeAndNode(indexA, indexB) {
  1821. var result = compareEdgeFieldName(ascending1, indexA, indexB);
  1822. if (result === 0)
  1823. result = compareNodeField(fieldName2, ascending2, indexA, indexB);
  1824. return result;
  1825. }
  1826.  
  1827. function compareNodeAndEdge(indexA, indexB) {
  1828. var result = compareNodeField(fieldName1, ascending1, indexA, indexB);
  1829. if (result === 0)
  1830. result = compareEdgeFieldName(ascending2, indexA, indexB);
  1831. return result;
  1832. }
  1833.  
  1834. function compareNodeAndNode(indexA, indexB) {
  1835. var result = compareNodeField(fieldName1, ascending1, indexA, indexB);
  1836. if (result === 0)
  1837. result = compareNodeField(fieldName2, ascending2, indexA, indexB);
  1838. return result;
  1839. }
  1840.  
  1841. if (fieldName1 === "!edgeName")
  1842. this._iterationOrder.sortRange(compareEdgeAndNode, leftBound, rightBound, count);
  1843. else if (fieldName2 === "!edgeName")
  1844. this._iterationOrder.sortRange(compareNodeAndEdge, leftBound, rightBound, count);
  1845. else
  1846. this._iterationOrder.sortRange(compareNodeAndNode, leftBound, rightBound, count);
  1847. },
  1848.  
  1849. __proto__: WebInspector.HeapSnapshotFilteredOrderedIterator.prototype
  1850. }
  1851.  
  1852.  
  1853.  
  1854. WebInspector.HeapSnapshotNodesProvider = function(snapshot, filter, nodeIndexes)
  1855. {
  1856. this.snapshot = snapshot;
  1857. WebInspector.HeapSnapshotFilteredOrderedIterator.call(this, snapshot._allNodes(), filter, nodeIndexes);
  1858. }
  1859.  
  1860. WebInspector.HeapSnapshotNodesProvider.prototype = {
  1861. nodePosition: function(snapshotObjectId)
  1862. {
  1863. this._createIterationOrder();
  1864. if (this.isEmpty())
  1865. return -1;
  1866. this.sortAll();
  1867.  
  1868. var node = new WebInspector.HeapSnapshotNode(this.snapshot);
  1869. for (var i = 0; i < this._iterationOrder.length; i++) {
  1870. node.nodeIndex = this._iterationOrder[i];
  1871. if (node.id() === snapshotObjectId)
  1872. return i;
  1873. }
  1874. return -1;
  1875. },
  1876.  
  1877. serializeItem: function(node)
  1878. {
  1879. return {
  1880. id: node.id(),
  1881. name: node.name(),
  1882. distanceToWindow: node.distanceToWindow(),
  1883. nodeIndex: node.nodeIndex,
  1884. retainedSize: node.retainedSize(),
  1885. selfSize: node.selfSize(),
  1886. type: node.type(),
  1887. flags: node.flags()
  1888. };
  1889. },
  1890.  
  1891. sort: function(comparator, leftBound, rightBound, count)
  1892. {
  1893. var fieldName1 = comparator.fieldName1;
  1894. var fieldName2 = comparator.fieldName2;
  1895. var ascending1 = comparator.ascending1;
  1896. var ascending2 = comparator.ascending2;
  1897.  
  1898. var nodeA = new WebInspector.HeapSnapshotNode(this.snapshot);
  1899. var nodeB = new WebInspector.HeapSnapshotNode(this.snapshot);
  1900.  
  1901. function sortByNodeField(fieldName, ascending)
  1902. {
  1903. var valueOrFunctionA = nodeA[fieldName];
  1904. var valueA = typeof valueOrFunctionA !== "function" ? valueOrFunctionA : valueOrFunctionA.call(nodeA);
  1905. var valueOrFunctionB = nodeB[fieldName];
  1906. var valueB = typeof valueOrFunctionB !== "function" ? valueOrFunctionB : valueOrFunctionB.call(nodeB);
  1907. var result = valueA < valueB ? -1 : (valueA > valueB ? 1 : 0);
  1908. return ascending ? result : -result;
  1909. }
  1910.  
  1911. function sortByComparator(indexA, indexB) {
  1912. nodeA.nodeIndex = indexA;
  1913. nodeB.nodeIndex = indexB;
  1914. var result = sortByNodeField(fieldName1, ascending1);
  1915. if (result === 0)
  1916. result = sortByNodeField(fieldName2, ascending2);
  1917. return result;
  1918. }
  1919.  
  1920. this._iterationOrder.sortRange(sortByComparator, leftBound, rightBound, count);
  1921. },
  1922.  
  1923. __proto__: WebInspector.HeapSnapshotFilteredOrderedIterator.prototype
  1924. }
  1925.  
  1926. ;
  1927.  
  1928.  
  1929.  
  1930. WebInspector.HeapSnapshotLoader = function()
  1931. {
  1932. this._reset();
  1933. }
  1934.  
  1935. WebInspector.HeapSnapshotLoader.prototype = {
  1936. dispose: function()
  1937. {
  1938. this._reset();
  1939. },
  1940.  
  1941. _reset: function()
  1942. {
  1943. this._json = "";
  1944. this._state = "find-snapshot-info";
  1945. this._snapshot = {};
  1946. },
  1947.  
  1948. close: function()
  1949. {
  1950. if (this._json)
  1951. this._parseStringsArray();
  1952. },
  1953.  
  1954. buildSnapshot: function()
  1955. {
  1956. var result = new WebInspector.HeapSnapshot(this._snapshot);
  1957. this._reset();
  1958. return result;
  1959. },
  1960.  
  1961. _parseUintArray: function()
  1962. {
  1963. var index = 0;
  1964. var char0 = "0".charCodeAt(0), char9 = "9".charCodeAt(0), closingBracket = "]".charCodeAt(0);
  1965. var length = this._json.length;
  1966. while (true) {
  1967. while (index < length) {
  1968. var code = this._json.charCodeAt(index);
  1969. if (char0 <= code && code <= char9)
  1970. break;
  1971. else if (code === closingBracket) {
  1972. this._json = this._json.slice(index + 1);
  1973. return false;
  1974. }
  1975. ++index;
  1976. }
  1977. if (index === length) {
  1978. this._json = "";
  1979. return true;
  1980. }
  1981. var nextNumber = 0;
  1982. var startIndex = index;
  1983. while (index < length) {
  1984. var code = this._json.charCodeAt(index);
  1985. if (char0 > code || code > char9)
  1986. break;
  1987. nextNumber *= 10;
  1988. nextNumber += (code - char0);
  1989. ++index;
  1990. }
  1991. if (index === length) {
  1992. this._json = this._json.slice(startIndex);
  1993. return true;
  1994. }
  1995. this._array[this._arrayIndex++] = nextNumber;
  1996. }
  1997. },
  1998.  
  1999. _parseStringsArray: function()
  2000. {
  2001. var closingBracketIndex = this._json.lastIndexOf("]");
  2002. if (closingBracketIndex === -1)
  2003. throw new Error("Incomplete JSON");
  2004. this._json = this._json.slice(0, closingBracketIndex + 1);
  2005. this._snapshot.strings = JSON.parse(this._json);
  2006. },
  2007.  
  2008.  
  2009. write: function(chunk)
  2010. {
  2011. this._json += chunk;
  2012. switch (this._state) {
  2013. case "find-snapshot-info": {
  2014. var snapshotToken = "\"snapshot\"";
  2015. var snapshotTokenIndex = this._json.indexOf(snapshotToken);
  2016. if (snapshotTokenIndex === -1)
  2017. throw new Error("Snapshot token not found");
  2018. this._json = this._json.slice(snapshotTokenIndex + snapshotToken.length + 1);
  2019. this._state = "parse-snapshot-info";
  2020. }
  2021. case "parse-snapshot-info": {
  2022. var closingBracketIndex = WebInspector.findBalancedCurlyBrackets(this._json);
  2023. if (closingBracketIndex === -1)
  2024. return;
  2025. this._snapshot.snapshot =   (JSON.parse(this._json.slice(0, closingBracketIndex)));
  2026. this._json = this._json.slice(closingBracketIndex);
  2027. this._state = "find-nodes";
  2028. }
  2029. case "find-nodes": {
  2030. var nodesToken = "\"nodes\"";
  2031. var nodesTokenIndex = this._json.indexOf(nodesToken);
  2032. if (nodesTokenIndex === -1)
  2033. return;
  2034. var bracketIndex = this._json.indexOf("[", nodesTokenIndex);
  2035. if (bracketIndex === -1)
  2036. return;
  2037. this._json = this._json.slice(bracketIndex + 1);
  2038. var node_fields_count = this._snapshot.snapshot.meta.node_fields.length;
  2039. var nodes_length = this._snapshot.snapshot.node_count * node_fields_count;
  2040. this._array = new Uint32Array(nodes_length);
  2041. this._arrayIndex = 0;
  2042. this._state = "parse-nodes";
  2043. }
  2044. case "parse-nodes": {
  2045. if (this._parseUintArray())
  2046. return;
  2047. this._snapshot.nodes = this._array;
  2048. this._state = "find-edges";
  2049. this._array = null;
  2050. }
  2051. case "find-edges": {
  2052. var edgesToken = "\"edges\"";
  2053. var edgesTokenIndex = this._json.indexOf(edgesToken);
  2054. if (edgesTokenIndex === -1)
  2055. return;
  2056. var bracketIndex = this._json.indexOf("[", edgesTokenIndex);
  2057. if (bracketIndex === -1)
  2058. return;
  2059. this._json = this._json.slice(bracketIndex + 1);
  2060. var edge_fields_count = this._snapshot.snapshot.meta.edge_fields.length;
  2061. var edges_length = this._snapshot.snapshot.edge_count * edge_fields_count;
  2062. this._array = new Uint32Array(edges_length);
  2063. this._arrayIndex = 0;
  2064. this._state = "parse-edges";
  2065. }
  2066. case "parse-edges": {
  2067. if (this._parseUintArray())
  2068. return;
  2069. this._snapshot.edges = this._array;
  2070. this._array = null;
  2071. this._state = "find-strings";
  2072. }
  2073. case "find-strings": {
  2074. var stringsToken = "\"strings\"";
  2075. var stringsTokenIndex = this._json.indexOf(stringsToken);
  2076. if (stringsTokenIndex === -1)
  2077. return;
  2078. var bracketIndex = this._json.indexOf("[", stringsTokenIndex);
  2079. if (bracketIndex === -1)
  2080. return;
  2081. this._json = this._json.slice(bracketIndex);
  2082. this._state = "accumulate-strings";
  2083. break;
  2084. }
  2085. case "accumulate-strings":
  2086. break;
  2087. }
  2088. }
  2089. };
  2090. ;
  2091.  
  2092.  
  2093.  
  2094. WebInspector.HeapSnapshotWorkerDispatcher = function(globalObject, postMessage)
  2095. {
  2096. this._objects = [];
  2097. this._global = globalObject;
  2098. this._postMessage = postMessage;
  2099. }
  2100.  
  2101. WebInspector.HeapSnapshotWorkerDispatcher.prototype = {
  2102. _findFunction: function(name)
  2103. {
  2104. var path = name.split(".");
  2105. var result = this._global;
  2106. for (var i = 0; i < path.length; ++i)
  2107. result = result[path[i]];
  2108. return result;
  2109. },
  2110.  
  2111. dispatchMessage: function(event)
  2112. {
  2113. var data = event.data;
  2114. var response = {callId: data.callId};
  2115. try {
  2116. switch (data.disposition) {
  2117. case "create": {
  2118. var constructorFunction = this._findFunction(data.methodName);
  2119. this._objects[data.objectId] = new constructorFunction();
  2120. break;
  2121. }
  2122. case "dispose": {
  2123. delete this._objects[data.objectId];
  2124. break;
  2125. }
  2126. case "getter": {
  2127. var object = this._objects[data.objectId];
  2128. var result = object[data.methodName];
  2129. response.result = result;
  2130. break;
  2131. }
  2132. case "factory": {
  2133. var object = this._objects[data.objectId];
  2134. var result = object[data.methodName].apply(object, data.methodArguments);
  2135. if (result)
  2136. this._objects[data.newObjectId] = result;
  2137. response.result = !!result;
  2138. break;
  2139. }
  2140. case "method": {
  2141. var object = this._objects[data.objectId];
  2142. response.result = object[data.methodName].apply(object, data.methodArguments);
  2143. break;
  2144. }
  2145. }
  2146. } catch (e) {
  2147. response.error = e.toString();
  2148. response.errorCallStack = e.stack;
  2149. if (data.methodName)
  2150. response.errorMethodName = data.methodName;
  2151. }
  2152. this._postMessage(response);
  2153. }
  2154. };
  2155. ;
  2156.  
  2157.  
  2158.  
  2159. WebInspector.OutputStreamDelegate = function()
  2160. {
  2161. }
  2162.  
  2163. WebInspector.OutputStreamDelegate.prototype = {
  2164. onTransferStarted: function() { },
  2165.  
  2166. onTransferFinished: function() { },
  2167.  
  2168.  
  2169. onChunkTransferred: function(reader) { },
  2170.  
  2171.  
  2172. onError: function(reader, event) { },
  2173. }
  2174.  
  2175.  
  2176. WebInspector.OutputStream = function()
  2177. {
  2178. }
  2179.  
  2180. WebInspector.OutputStream.prototype = {
  2181.  
  2182. write: function(data, callback) { },
  2183.  
  2184. close: function() { }
  2185. }
  2186.  
  2187.  
  2188. WebInspector.ChunkedReader = function()
  2189. {
  2190. }
  2191.  
  2192. WebInspector.ChunkedReader.prototype = {
  2193.  
  2194. fileSize: function() { },
  2195.  
  2196.  
  2197. loadedSize: function() { },
  2198.  
  2199.  
  2200. fileName: function() { },
  2201.  
  2202. cancel: function() { }
  2203. }
  2204.  
  2205.  
  2206. WebInspector.ChunkedFileReader = function(file, chunkSize, delegate)
  2207. {
  2208. this._file = file;
  2209. this._fileSize = file.size;
  2210. this._loadedSize = 0;
  2211. this._chunkSize = chunkSize;
  2212. this._delegate = delegate;
  2213. this._isCanceled = false;
  2214. }
  2215.  
  2216. WebInspector.ChunkedFileReader.prototype = {
  2217.  
  2218. start: function(output)
  2219. {
  2220. this._output = output;
  2221.  
  2222. this._reader = new FileReader();
  2223. this._reader.onload = this._onChunkLoaded.bind(this);
  2224. this._reader.onerror = this._delegate.onError.bind(this._delegate, this);
  2225. this._delegate.onTransferStarted();
  2226. this._loadChunk();
  2227. },
  2228.  
  2229. cancel: function()
  2230. {
  2231. this._isCanceled = true;
  2232. },
  2233.  
  2234.  
  2235. loadedSize: function()
  2236. {
  2237. return this._loadedSize;
  2238. },
  2239.  
  2240.  
  2241. fileSize: function()
  2242. {
  2243. return this._fileSize;
  2244. },
  2245.  
  2246.  
  2247. fileName: function()
  2248. {
  2249. return this._file.name;
  2250. },
  2251.  
  2252.  
  2253. _onChunkLoaded: function(event)
  2254. {
  2255. if (this._isCanceled)
  2256. return;
  2257.  
  2258. if (event.target.readyState !== FileReader.DONE)
  2259. return;
  2260.  
  2261. var data = event.target.result;
  2262. this._loadedSize += data.length;
  2263.  
  2264. this._output.write(data);
  2265. if (this._isCanceled)
  2266. return;
  2267. this._delegate.onChunkTransferred(this);
  2268.  
  2269. if (this._loadedSize === this._fileSize) {
  2270. this._file = null;
  2271. this._reader = null;
  2272. this._output.close();
  2273. this._delegate.onTransferFinished();
  2274. return;
  2275. }
  2276.  
  2277. this._loadChunk();
  2278. },
  2279.  
  2280. _loadChunk: function()
  2281. {
  2282. var chunkStart = this._loadedSize;
  2283. var chunkEnd = Math.min(this._fileSize, chunkStart + this._chunkSize)
  2284. var nextPart = this._file.slice(chunkStart, chunkEnd);
  2285. this._reader.readAsText(nextPart);
  2286. }
  2287. }
  2288.  
  2289.  
  2290. WebInspector.ChunkedXHRReader = function(url, delegate)
  2291. {
  2292. this._url = url;
  2293. this._delegate = delegate;
  2294. this._fileSize = 0;
  2295. this._loadedSize = 0;
  2296. this._isCanceled = false;
  2297. }
  2298.  
  2299. WebInspector.ChunkedXHRReader.prototype = {
  2300.  
  2301. start: function(output)
  2302. {
  2303. this._output = output;
  2304.  
  2305. this._xhr = new XMLHttpRequest();
  2306. this._xhr.open("GET", this._url, true);
  2307. this._xhr.onload = this._onLoad.bind(this);
  2308. this._xhr.onprogress = this._onProgress.bind(this);
  2309. this._xhr.onerror = this._delegate.onError.bind(this._delegate, this);
  2310. this._xhr.send(null);
  2311.  
  2312. this._delegate.onTransferStarted();
  2313. },
  2314.  
  2315. cancel: function()
  2316. {
  2317. this._isCanceled = true;
  2318. this._xhr.abort();
  2319. },
  2320.  
  2321.  
  2322. loadedSize: function()
  2323. {
  2324. return this._loadedSize;
  2325. },
  2326.  
  2327.  
  2328. fileSize: function()
  2329. {
  2330. return this._fileSize;
  2331. },
  2332.  
  2333.  
  2334. fileName: function()
  2335. {
  2336. return this._url;
  2337. },
  2338.  
  2339.  
  2340. _onProgress: function(event)
  2341. {
  2342. if (this._isCanceled)
  2343. return;
  2344.  
  2345. if (event.lengthComputable)
  2346. this._fileSize = event.total;
  2347.  
  2348. var data = this._xhr.responseText.substring(this._loadedSize);
  2349. if (!data.length)
  2350. return;
  2351.  
  2352. this._loadedSize += data.length;
  2353. this._output.write(data);
  2354. if (this._isCanceled)
  2355. return;
  2356. this._delegate.onChunkTransferred(this);
  2357. },
  2358.  
  2359.  
  2360. _onLoad: function(event)
  2361. {
  2362. this._onProgress(event);
  2363.  
  2364. if (this._isCanceled)
  2365. return;
  2366.  
  2367. this._output.close();
  2368. this._delegate.onTransferFinished();
  2369. }
  2370. }
  2371.  
  2372.  
  2373. WebInspector.createFileSelectorElement = function(callback) {
  2374. var fileSelectorElement = document.createElement("input");
  2375. fileSelectorElement.type = "file";
  2376. fileSelectorElement.style.zIndex = -1;
  2377. fileSelectorElement.style.position = "absolute";
  2378. fileSelectorElement.onchange = function(event) {
  2379. callback(fileSelectorElement.files[0]);
  2380. };
  2381. return fileSelectorElement;
  2382. }
  2383.  
  2384.  
  2385. WebInspector.findBalancedCurlyBrackets = function(source, startIndex, lastIndex) {
  2386. lastIndex = lastIndex || source.length;
  2387. startIndex = startIndex || 0;
  2388. var counter = 0;
  2389. var inString = false;
  2390.  
  2391. for (var index = startIndex; index < lastIndex; ++index) {
  2392. var character = source[index];
  2393. if (inString) {
  2394. if (character === "\\")
  2395. ++index;
  2396. else if (character === "\"")
  2397. inString = false;
  2398. } else {
  2399. if (character === "\"")
  2400. inString = true;
  2401. else if (character === "{")
  2402. ++counter;
  2403. else if (character === "}") {
  2404. if (--counter === 0)
  2405. return index + 1;
  2406. }
  2407. }
  2408. }
  2409. return -1;
  2410. }
  2411.  
  2412.  
  2413. WebInspector.FileOutputStream = function()
  2414. {
  2415. }
  2416.  
  2417. WebInspector.FileOutputStream.prototype = {
  2418.  
  2419. open: function(fileName, callback)
  2420. {
  2421. this._closed = false;
  2422. this._writeCallbacks = [];
  2423. this._fileName = fileName;
  2424. function callbackWrapper()
  2425. {
  2426. WebInspector.fileManager.removeEventListener(WebInspector.FileManager.EventTypes.SavedURL, callbackWrapper, this);
  2427. WebInspector.fileManager.addEventListener(WebInspector.FileManager.EventTypes.AppendedToURL, this._onAppendDone, this);
  2428. callback(this);
  2429. }
  2430. WebInspector.fileManager.addEventListener(WebInspector.FileManager.EventTypes.SavedURL, callbackWrapper, this);
  2431. WebInspector.fileManager.save(this._fileName, "", true);
  2432. },
  2433.  
  2434.  
  2435. write: function(data, callback)
  2436. {
  2437. this._writeCallbacks.push(callback);
  2438. WebInspector.fileManager.append(this._fileName, data);
  2439. },
  2440.  
  2441. close: function()
  2442. {
  2443. this._closed = true;
  2444. if (this._writeCallbacks.length)
  2445. return;
  2446. WebInspector.fileManager.removeEventListener(WebInspector.FileManager.EventTypes.AppendedToURL, this._onAppendDone, this);
  2447. WebInspector.fileManager.close(this._fileName);
  2448. },
  2449.  
  2450.  
  2451. _onAppendDone: function(event)
  2452. {
  2453. if (event.data !== this._fileName)
  2454. return;
  2455. if (!this._writeCallbacks.length) {
  2456. if (this._closed) {
  2457. WebInspector.fileManager.removeEventListener(WebInspector.FileManager.EventTypes.AppendedToURL, this._onAppendDone, this);
  2458. WebInspector.fileManager.close(this._fileName);
  2459. }
  2460. return;
  2461. }
  2462. var callback = this._writeCallbacks.shift();
  2463. if (callback)
  2464. callback(this);
  2465. }
  2466. }
  2467. ;
  2468.  
  2469.  
  2470. Object.isEmpty = function(obj)
  2471. {
  2472. for (var i in obj)
  2473. return false;
  2474. return true;
  2475. }
  2476.  
  2477. Object.values = function(obj)
  2478. {
  2479. var keys = Object.keys(obj);
  2480. var result = [];
  2481.  
  2482. for (var i = 0; i < keys.length; ++i)
  2483. result.push(obj[keys[i]]);
  2484. return result;
  2485. }
  2486.  
  2487. String.prototype.hasSubstring = function(string, caseInsensitive)
  2488. {
  2489. if (!caseInsensitive)
  2490. return this.indexOf(string) !== -1;
  2491. return this.match(new RegExp(string.escapeForRegExp(), "i"));
  2492. }
  2493.  
  2494. String.prototype.findAll = function(string)
  2495. {
  2496. var matches = [];
  2497. var i = this.indexOf(string);
  2498. while (i !== -1) {
  2499. matches.push(i);
  2500. i = this.indexOf(string, i + string.length);
  2501. }
  2502. return matches;
  2503. }
  2504.  
  2505. String.prototype.lineEndings = function()
  2506. {
  2507. if (!this._lineEndings) {
  2508. this._lineEndings = this.findAll("\n");
  2509. this._lineEndings.push(this.length);
  2510. }
  2511. return this._lineEndings;
  2512. }
  2513.  
  2514. String.prototype.escapeCharacters = function(chars)
  2515. {
  2516. var foundChar = false;
  2517. for (var i = 0; i < chars.length; ++i) {
  2518. if (this.indexOf(chars.charAt(i)) !== -1) {
  2519. foundChar = true;
  2520. break;
  2521. }
  2522. }
  2523.  
  2524. if (!foundChar)
  2525. return this;
  2526.  
  2527. var result = "";
  2528. for (var i = 0; i < this.length; ++i) {
  2529. if (chars.indexOf(this.charAt(i)) !== -1)
  2530. result += "\\";
  2531. result += this.charAt(i);
  2532. }
  2533.  
  2534. return result;
  2535. }
  2536.  
  2537. String.prototype.escapeForRegExp = function()
  2538. {
  2539. return this.escapeCharacters("^[]{}()\\.$*+?|");
  2540. }
  2541.  
  2542. String.prototype.escapeHTML = function()
  2543. {
  2544. return this.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """); 
  2545. }
  2546.  
  2547. String.prototype.collapseWhitespace = function()
  2548. {
  2549. return this.replace(/[\s\xA0]+/g, " ");
  2550. }
  2551.  
  2552. String.prototype.trimMiddle = function(maxLength)
  2553. {
  2554. if (this.length <= maxLength)
  2555. return this;
  2556. var leftHalf = maxLength >> 1;
  2557. var rightHalf = maxLength - leftHalf - 1;
  2558. return this.substr(0, leftHalf) + "\u2026" + this.substr(this.length - rightHalf, rightHalf);
  2559. }
  2560.  
  2561. String.prototype.trimEnd = function(maxLength)
  2562. {
  2563. if (this.length <= maxLength)
  2564. return this;
  2565. return this.substr(0, maxLength - 1) + "\u2026";
  2566. }
  2567.  
  2568. String.prototype.trimURL = function(baseURLDomain)
  2569. {
  2570. var result = this.replace(/^(https|http|file):\/\//i, "");
  2571. if (baseURLDomain)
  2572. result = result.replace(new RegExp("^" + baseURLDomain.escapeForRegExp(), "i"), "");
  2573. return result;
  2574. }
  2575.  
  2576.  
  2577. function sanitizeHref(href)
  2578. {
  2579. return href && href.trim().toLowerCase().startsWith("javascript:") ? "" : href;
  2580. }
  2581.  
  2582. String.prototype.removeURLFragment = function()
  2583. {
  2584. var fragmentIndex = this.indexOf("#");
  2585. if (fragmentIndex == -1)
  2586. fragmentIndex = this.length;
  2587. return this.substring(0, fragmentIndex);
  2588. }
  2589.  
  2590. String.prototype.startsWith = function(substring)
  2591. {
  2592. return !this.lastIndexOf(substring, 0);
  2593. }
  2594.  
  2595. String.prototype.endsWith = function(substring)
  2596. {
  2597. return this.indexOf(substring, this.length - substring.length) !== -1;
  2598. }
  2599.  
  2600. Number.constrain = function(num, min, max)
  2601. {
  2602. if (num < min)
  2603. num = min;
  2604. else if (num > max)
  2605. num = max;
  2606. return num;
  2607. }
  2608.  
  2609. Date.prototype.toISO8601Compact = function()
  2610. {
  2611. function leadZero(x)
  2612. {
  2613. return x > 9 ? '' + x : '0' + x
  2614. }
  2615. return this.getFullYear() +
  2616. leadZero(this.getMonth() + 1) +
  2617. leadZero(this.getDate()) + 'T' +
  2618. leadZero(this.getHours()) +
  2619. leadZero(this.getMinutes()) +
  2620. leadZero(this.getSeconds());
  2621. }
  2622.  
  2623. Object.defineProperty(Array.prototype, "remove",
  2624. {
  2625.  
  2626. value: function(value, onlyFirst)
  2627. {
  2628. if (onlyFirst) {
  2629. var index = this.indexOf(value);
  2630. if (index !== -1)
  2631. this.splice(index, 1);
  2632. return;
  2633. }
  2634.  
  2635. var length = this.length;
  2636. for (var i = 0; i < length; ++i) {
  2637. if (this[i] === value)
  2638. this.splice(i, 1);
  2639. }
  2640. }
  2641. });
  2642.  
  2643. Object.defineProperty(Array.prototype, "keySet",
  2644. {
  2645.  
  2646. value: function()
  2647. {
  2648. var keys = {};
  2649. for (var i = 0; i < this.length; ++i)
  2650. keys[this[i]] = true;
  2651. return keys;
  2652. }
  2653. });
  2654.  
  2655. Object.defineProperty(Array.prototype, "upperBound",
  2656. {
  2657.  
  2658. value: function(value)
  2659. {
  2660. var first = 0;
  2661. var count = this.length;
  2662. while (count > 0) {
  2663. var step = count >> 1;
  2664. var middle = first + step;
  2665. if (value >= this[middle]) {
  2666. first = middle + 1;
  2667. count -= step + 1;
  2668. } else
  2669. count = step;
  2670. }
  2671. return first;
  2672. }
  2673. });
  2674.  
  2675. Object.defineProperty(Array.prototype, "rotate",
  2676. {
  2677.  
  2678. value: function(index)
  2679. {
  2680. var result = [];
  2681. for (var i = index; i < index + this.length; ++i)
  2682. result.push(this[i % this.length]);
  2683. return result;
  2684. }
  2685. });
  2686.  
  2687. Object.defineProperty(Uint32Array.prototype, "sort", {
  2688. value: Array.prototype.sort
  2689. });
  2690.  
  2691. (function() {
  2692. var partition = {
  2693.  
  2694. value: function(comparator, left, right, pivotIndex)
  2695. {
  2696. function swap(array, i1, i2)
  2697. {
  2698. var temp = array[i1];
  2699. array[i1] = array[i2];
  2700. array[i2] = temp;
  2701. }
  2702.  
  2703. var pivotValue = this[pivotIndex];
  2704. swap(this, right, pivotIndex);
  2705. var storeIndex = left;
  2706. for (var i = left; i < right; ++i) {
  2707. if (comparator(this[i], pivotValue) < 0) {
  2708. swap(this, storeIndex, i);
  2709. ++storeIndex;
  2710. }
  2711. }
  2712. swap(this, right, storeIndex);
  2713. return storeIndex;
  2714. }
  2715. };
  2716. Object.defineProperty(Array.prototype, "partition", partition);
  2717. Object.defineProperty(Uint32Array.prototype, "partition", partition);
  2718.  
  2719. var sortRange = {
  2720.  
  2721. value: function(comparator, leftBound, rightBound, k)
  2722. {
  2723. function quickSortFirstK(array, comparator, left, right, k)
  2724. {
  2725. if (right <= left)
  2726. return;
  2727. var pivotIndex = Math.floor(Math.random() * (right - left)) + left;
  2728. var pivotNewIndex = array.partition(comparator, left, right, pivotIndex);
  2729. quickSortFirstK(array, comparator, left, pivotNewIndex - 1, k);
  2730. if (pivotNewIndex < left + k - 1)
  2731. quickSortFirstK(array, comparator, pivotNewIndex + 1, right, k);
  2732. }
  2733.  
  2734. if (leftBound === 0 && rightBound === (this.length - 1) && k === this.length)
  2735. this.sort(comparator);
  2736. else
  2737. quickSortFirstK(this, comparator, leftBound, rightBound, k);
  2738. return this;
  2739. }
  2740. }
  2741. Object.defineProperty(Array.prototype, "sortRange", sortRange);
  2742. Object.defineProperty(Uint32Array.prototype, "sortRange", sortRange);
  2743. })();
  2744.  
  2745. Object.defineProperty(Array.prototype, "qselect",
  2746. {
  2747.  
  2748. value: function(k, comparator)
  2749. {
  2750. if (k < 0 || k >= this.length)
  2751. return;
  2752. if (!comparator)
  2753. comparator = function(a, b) { return a - b; }
  2754.  
  2755. var low = 0;
  2756. var high = this.length - 1;
  2757. for (;;) {
  2758. var pivotPosition = this.partition(comparator, low, high, Math.floor((high + low) / 2));
  2759. if (pivotPosition === k)
  2760. return this[k];
  2761. else if (pivotPosition > k)
  2762. high = pivotPosition - 1;
  2763. else
  2764. low = pivotPosition + 1;
  2765. }
  2766. }
  2767. });
  2768.  
  2769.  
  2770. function binarySearch(object, array, comparator)
  2771. {
  2772. var first = 0;
  2773. var last = array.length - 1;
  2774.  
  2775. while (first <= last) {
  2776. var mid = (first + last) >> 1;
  2777. var c = comparator(object, array[mid]);
  2778. if (c > 0)
  2779. first = mid + 1;
  2780. else if (c < 0)
  2781. last = mid - 1;
  2782. else
  2783. return mid;
  2784. }
  2785.  
  2786.  
  2787. return -(first + 1);
  2788. }
  2789.  
  2790. Object.defineProperty(Array.prototype, "binaryIndexOf",
  2791. {
  2792.  
  2793. value: function(value, comparator)
  2794. {
  2795. var result = binarySearch(value, this, comparator);
  2796. return result >= 0 ? result : -1;
  2797. }
  2798. });
  2799.  
  2800. Object.defineProperty(Array.prototype, "select",
  2801. {
  2802.  
  2803. value: function(field)
  2804. {
  2805. var result = new Array(this.length);
  2806. for (var i = 0; i < this.length; ++i)
  2807. result[i] = this[i][field];
  2808. return result;
  2809. }
  2810. });
  2811.  
  2812.  
  2813. function insertionIndexForObjectInListSortedByFunction(anObject, aList, aFunction)
  2814. {
  2815. var index = binarySearch(anObject, aList, aFunction);
  2816. if (index < 0)
  2817.  
  2818. return -index - 1;
  2819. else {
  2820.  
  2821. while (index > 0 && aFunction(anObject, aList[index - 1]) === 0)
  2822. index--;
  2823. return index;
  2824. }
  2825. }
  2826.  
  2827.  
  2828. String.sprintf = function(format, var_arg)
  2829. {
  2830. return String.vsprintf(format, Array.prototype.slice.call(arguments, 1));
  2831. }
  2832.  
  2833. String.tokenizeFormatString = function(format, formatters)
  2834. {
  2835. var tokens = [];
  2836. var substitutionIndex = 0;
  2837.  
  2838. function addStringToken(str)
  2839. {
  2840. tokens.push({ type: "string", value: str });
  2841. }
  2842.  
  2843. function addSpecifierToken(specifier, precision, substitutionIndex)
  2844. {
  2845. tokens.push({ type: "specifier", specifier: specifier, precision: precision, substitutionIndex: substitutionIndex });
  2846. }
  2847.  
  2848. function isDigit(c)
  2849. {
  2850. return !!/[0-9]/.exec(c);
  2851. }
  2852.  
  2853. var index = 0;
  2854. for (var precentIndex = format.indexOf("%", index); precentIndex !== -1; precentIndex = format.indexOf("%", index)) {
  2855. addStringToken(format.substring(index, precentIndex));
  2856. index = precentIndex + 1;
  2857.  
  2858. if (isDigit(format[index])) {
  2859.  
  2860. var number = parseInt(format.substring(index), 10);
  2861. while (isDigit(format[index]))
  2862. ++index;
  2863.  
  2864.  
  2865.  
  2866. if (number > 0 && format[index] === "$") {
  2867. substitutionIndex = (number - 1);
  2868. ++index;
  2869. }
  2870. }
  2871.  
  2872. var precision = -1;
  2873. if (format[index] === ".") {
  2874.  
  2875.  
  2876. ++index;
  2877. precision = parseInt(format.substring(index), 10);
  2878. if (isNaN(precision))
  2879. precision = 0;
  2880.  
  2881. while (isDigit(format[index]))
  2882. ++index;
  2883. }
  2884.  
  2885. if (!(format[index] in formatters)) {
  2886. addStringToken(format.substring(precentIndex, index + 1));
  2887. ++index;
  2888. continue;
  2889. }
  2890.  
  2891. addSpecifierToken(format[index], precision, substitutionIndex);
  2892.  
  2893. ++substitutionIndex;
  2894. ++index;
  2895. }
  2896.  
  2897. addStringToken(format.substring(index));
  2898.  
  2899. return tokens;
  2900. }
  2901.  
  2902. String.standardFormatters = {
  2903. d: function(substitution)
  2904. {
  2905. return !isNaN(substitution) ? substitution : 0;
  2906. },
  2907.  
  2908. f: function(substitution, token)
  2909. {
  2910. if (substitution && token.precision > -1)
  2911. substitution = substitution.toFixed(token.precision);
  2912. return !isNaN(substitution) ? substitution : (token.precision > -1 ? Number(0).toFixed(token.precision) : 0);
  2913. },
  2914.  
  2915. s: function(substitution)
  2916. {
  2917. return substitution;
  2918. }
  2919. }
  2920.  
  2921. String.vsprintf = function(format, substitutions)
  2922. {
  2923. return String.format(format, substitutions, String.standardFormatters, "", function(a, b) { return a + b; }).formattedResult;
  2924. }
  2925.  
  2926. String.format = function(format, substitutions, formatters, initialValue, append)
  2927. {
  2928. if (!format || !substitutions || !substitutions.length)
  2929. return { formattedResult: append(initialValue, format), unusedSubstitutions: substitutions };
  2930.  
  2931. function prettyFunctionName()
  2932. {
  2933. return "String.format(\"" + format + "\", \"" + substitutions.join("\", \"") + "\")";
  2934. }
  2935.  
  2936. function warn(msg)
  2937. {
  2938. console.warn(prettyFunctionName() + ": " + msg);
  2939. }
  2940.  
  2941. function error(msg)
  2942. {
  2943. console.error(prettyFunctionName() + ": " + msg);
  2944. }
  2945.  
  2946. var result = initialValue;
  2947. var tokens = String.tokenizeFormatString(format, formatters);
  2948. var usedSubstitutionIndexes = {};
  2949.  
  2950. for (var i = 0; i < tokens.length; ++i) {
  2951. var token = tokens[i];
  2952.  
  2953. if (token.type === "string") {
  2954. result = append(result, token.value);
  2955. continue;
  2956. }
  2957.  
  2958. if (token.type !== "specifier") {
  2959. error("Unknown token type \"" + token.type + "\" found.");
  2960. continue;
  2961. }
  2962.  
  2963. if (token.substitutionIndex >= substitutions.length) {
  2964.  
  2965.  
  2966. error("not enough substitution arguments. Had " + substitutions.length + " but needed " + (token.substitutionIndex + 1) + ", so substitution was skipped.");
  2967. result = append(result, "%" + (token.precision > -1 ? token.precision : "") + token.specifier);
  2968. continue;
  2969. }
  2970.  
  2971. usedSubstitutionIndexes[token.substitutionIndex] = true;
  2972.  
  2973. if (!(token.specifier in formatters)) {
  2974.  
  2975. warn("unsupported format character \u201C" + token.specifier + "\u201D. Treating as a string.");
  2976. result = append(result, substitutions[token.substitutionIndex]);
  2977. continue;
  2978. }
  2979.  
  2980. result = append(result, formatters[token.specifier](substitutions[token.substitutionIndex], token));
  2981. }
  2982.  
  2983. var unusedSubstitutions = [];
  2984. for (var i = 0; i < substitutions.length; ++i) {
  2985. if (i in usedSubstitutionIndexes)
  2986. continue;
  2987. unusedSubstitutions.push(substitutions[i]);
  2988. }
  2989.  
  2990. return { formattedResult: result, unusedSubstitutions: unusedSubstitutions };
  2991. }
  2992.  
  2993.  
  2994. function createSearchRegex(query, caseSensitive, isRegex)
  2995. {
  2996. var regexFlags = caseSensitive ? "g" : "gi";
  2997. var regexObject;
  2998.  
  2999. if (isRegex) {
  3000. try {
  3001. regexObject = new RegExp(query, regexFlags);
  3002. } catch (e) {
  3003.  
  3004. }
  3005. }
  3006.  
  3007. if (!regexObject)
  3008. regexObject = createPlainTextSearchRegex(query, regexFlags);
  3009.  
  3010. return regexObject;
  3011. }
  3012.  
  3013.  
  3014. function createPlainTextSearchRegex(query, flags)
  3015. {
  3016.  
  3017. var regexSpecialCharacters = "[](){}+-*.,?\\^$|";
  3018. var regex = "";
  3019. for (var i = 0; i < query.length; ++i) {
  3020. var c = query.charAt(i);
  3021. if (regexSpecialCharacters.indexOf(c) != -1)
  3022. regex += "\\";
  3023. regex += c;
  3024. }
  3025. return new RegExp(regex, flags || "");
  3026. }
  3027.  
  3028.  
  3029. function countRegexMatches(regex, content)
  3030. {
  3031. var text = content;
  3032. var result = 0;
  3033. var match;
  3034. while (text && (match = regex.exec(text))) {
  3035. if (match[0].length > 0)
  3036. ++result;
  3037. text = text.substring(match.index + 1);
  3038. }
  3039. return result;
  3040. }
  3041.  
  3042.  
  3043. function numberToStringWithSpacesPadding(value, symbolsCount)
  3044. {
  3045. var numberString = value.toString();
  3046. var paddingLength = Math.max(0, symbolsCount - numberString.length);
  3047. var paddingString = Array(paddingLength + 1).join("\u00a0");
  3048. return paddingString + numberString;
  3049. }
  3050.  
  3051.  
  3052. var Map = function()
  3053. {
  3054. this._map = {};
  3055. this._size = 0;
  3056. }
  3057.  
  3058. Map._lastObjectIdentifier = 0;
  3059.  
  3060. Map.prototype = {
  3061.  
  3062. put: function(key, value)
  3063. {
  3064. var objectIdentifier = key.__identifier;
  3065. if (!objectIdentifier) {
  3066. objectIdentifier = ++Map._lastObjectIdentifier;
  3067. key.__identifier = objectIdentifier;
  3068. }
  3069. if (!this._map[objectIdentifier])
  3070. ++this._size;
  3071. this._map[objectIdentifier] = [key, value];
  3072. },
  3073.  
  3074.  
  3075. remove: function(key)
  3076. {
  3077. var result = this._map[key.__identifier];
  3078. if (!result)
  3079. return undefined;
  3080. --this._size;
  3081. delete this._map[key.__identifier];
  3082. return result[1];
  3083. },
  3084.  
  3085.  
  3086. keys: function()
  3087. {
  3088. return this._list(0);
  3089. },
  3090.  
  3091. values: function()
  3092. {
  3093. return this._list(1);
  3094. },
  3095.  
  3096.  
  3097. _list: function(index)
  3098. {
  3099. var result = new Array(this._size);
  3100. var i = 0;
  3101. for (var objectIdentifier in this._map)
  3102. result[i++] = this._map[objectIdentifier][index];
  3103. return result;
  3104. },
  3105.  
  3106.  
  3107. get: function(key)
  3108. {
  3109. var entry = this._map[key.__identifier];
  3110. return entry ? entry[1] : undefined;
  3111. },
  3112.  
  3113. size: function()
  3114. {
  3115. return this._size;
  3116. },
  3117.  
  3118. clear: function()
  3119. {
  3120. this._map = {};
  3121. this._size = 0;
  3122. }
  3123. }
  3124.  
  3125. function loadXHR(url, async, callback) 
  3126. {
  3127. function onReadyStateChanged() 
  3128. {
  3129. if (xhr.readyState !== XMLHttpRequest.DONE)
  3130. return;
  3131.  
  3132. if (xhr.status === 200) {
  3133. callback(xhr.responseText);
  3134. return;
  3135. }
  3136.  
  3137. callback(null); 
  3138. }
  3139.  
  3140. var xhr = new XMLHttpRequest();
  3141. xhr.open("GET", url, async);
  3142. if (async)
  3143. xhr.onreadystatechange = onReadyStateChanged;        
  3144. xhr.send(null);
  3145.  
  3146. if (!async) {
  3147. if (xhr.status === 200) 
  3148. return xhr.responseText;
  3149. return null;
  3150. }
  3151. return null;
  3152. }
  3153.  
  3154.  
  3155. function StringPool()
  3156. {
  3157. this.reset();
  3158. }
  3159.  
  3160. StringPool.prototype = {
  3161.  
  3162. intern: function(string)
  3163. {
  3164.  
  3165. if (string === "__proto__")
  3166. return "__proto__";
  3167. var result = this._strings[string];
  3168. if (result === undefined) {
  3169. this._strings[string] = string;
  3170. result = string;
  3171. }
  3172. return result;
  3173. },
  3174.  
  3175. reset: function()
  3176. {
  3177. this._strings = Object.create(null);
  3178. },
  3179.  
  3180.  
  3181. internObjectStrings: function(obj, depthLimit)
  3182. {
  3183. if (typeof depthLimit !== "number")
  3184. depthLimit = 100;
  3185. else if (--depthLimit < 0)
  3186. throw "recursion depth limit reached in StringPool.deepIntern(), perhaps attempting to traverse cyclical references?";
  3187.  
  3188. for (var field in obj) {
  3189. switch (typeof obj[field]) {
  3190. case "string":
  3191. obj[field] = this.intern(obj[field]);
  3192. break;
  3193. case "object":
  3194. this.internObjectStrings(obj[field], depthLimit);
  3195. break;
  3196. }
  3197. }
  3198. }
  3199. }
  3200.  
  3201. var _importedScripts = {};
  3202.  
  3203.  
  3204. function importScript(scriptName)
  3205. {
  3206. if (_importedScripts[scriptName])
  3207. return;
  3208. _importedScripts[scriptName] = true;
  3209. var xhr = new XMLHttpRequest();
  3210. xhr.open("GET", scriptName, false);
  3211. xhr.send(null);
  3212. window.eval(xhr.responseText + "\n//@ sourceURL=" + scriptName);
  3213. }
  3214. ;
  3215.  
  3216. function postMessageWrapper(message)
  3217. {
  3218. postMessage(message);
  3219. }
  3220.  
  3221.  
  3222. WebInspector.WorkerConsole = function()
  3223. {
  3224. }
  3225.  
  3226. WebInspector.WorkerConsole.prototype = {
  3227.  
  3228. log: function(var_args)
  3229. {
  3230. this._postMessage("log", Array.prototype.slice.call(arguments));
  3231. },
  3232.  
  3233.  
  3234. error: function(var_args)
  3235. {
  3236. this._postMessage("error", Array.prototype.slice.call(arguments));
  3237. },
  3238.  
  3239.  
  3240. info: function(var_args)
  3241. {
  3242. this._postMessage("info", Array.prototype.slice.call(arguments));
  3243. },
  3244.  
  3245. trace: function()
  3246. {
  3247. this.log(new Error().stack);
  3248. },
  3249.  
  3250.  
  3251.  
  3252. _postMessage: function(method, args)
  3253. {
  3254. var rawMessage = {
  3255. object: "console",
  3256. method: method,
  3257. arguments: args
  3258. };
  3259. postMessageWrapper(rawMessage);
  3260. }
  3261. };
  3262.  
  3263. var dispatcher = new WebInspector.HeapSnapshotWorkerDispatcher(this, postMessageWrapper);
  3264. addEventListener("message", dispatcher.dispatchMessage.bind(dispatcher), false);
  3265. console = new WebInspector.WorkerConsole();
  3266.